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

Annotations already indicate a non-idempotent write operation, and the description adds no behavioral context beyond the word 'add'. It does not mention auth requirements, whether the changelog replaces or appends to an existing version entry, or the effect of repeated calls.

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

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

Two short sentences, no filler, and the core purpose is front-loaded. Both sentences carry information and the structure is scannable.

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 three-string mutation tool with annotations present, the description is minimally viable: the action, target, and one critical parameter source are stated. However, missing version/changelog semantics and duplicate/append behavior leave gaps that could cause incorrect 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 for the three string parameters is 0%, and the description only explains how to obtain mod_uid. It leaves version and changelog formats unspecified, so an agent cannot tell what values are valid beyond non-empty strings.

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 action and object ('Add changelog text for a version of a mod'), which clearly differentiates from read-only siblings like get_changelogs. It does not explicitly name an alternative, 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?

The sentence 'mod_uid from get_upload_targets' gives a concrete prerequisite for obtaining a required parameter, implying a workflow. It does not say when to prefer this tool over alternatives, nor does it provide exclusions or fallback conditions.

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

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

Annotations already declare readOnlyHint=false, idempotentHint=false, and destructiveHint=false, so the description is not required to repeat those. It adds value by disclosing the authentication requirement (author's web session) and implying the operation mirrors the editor UI. It does not describe failure modes or side effects, but given annotation coverage, a 3 is fair.

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 exactly two sentences with zero filler. The primary purpose is front-loaded, and the auth requirement is stated efficiently. No redundancy with schema or annotations.

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 only partial schema descriptions, the description is too sparse. It omits behavior on invalid URLs, duplicate videos, or the response format. While annotations cover safety, they do not cover operational details. The tool would benefit from explaining the dry_run option and what a successful add looks like.

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 33%, meaning most parameters (title, mod_id, description) lack documentation. The description adds no parameter-level detail, so it does not compensate for the low coverage. For example, it does not clarify that 'title' is a required display name or that 'description' is optional. This is a significant gap.

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

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

The description clearly states the action: 'Add a YouTube video to YOUR mod's Videos tab'. It identifies the resource (mod's Videos tab) and the verb (add), and distinguishes it from sibling delete_mod_video by implying the inverse operation. The phrase 'as the mod editor does' anchors it to a known UI action.

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 states a key prerequisite: 'Needs the author's web session', which tells the agent when this tool is appropriate (only for the mod author). However, it does not explicitly name alternatives (like delete_mod_video) or state when not to use it, leaving the routing 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?

Annotations already declare destructiveHint=true and idempotentHint=true. The description adds the crucial 'Cannot be undone' warning and notes it operates via a web session, which is useful behavioral context beyond the annotations. No contradiction with annotations.

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

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

Two short sentences with zero waste. The core action is front-loaded, and the irreversibility warning is included without padding.

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 single-parameter destructive tool with annotations covering idempotency and destructiveness, the description is nearly complete. It could mention what happens to the comment (e.g., whether it disappears for others immediately), but the 'Cannot be undone' warning covers the essential risk.

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

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

Schema description coverage is 0%, so the description carries the burden. The description doesn't explain what comment_id refers to beyond the obvious, but with a single required parameter named comment_id, the meaning is largely self-evident. The description adds no extra detail about the parameter format or source.

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

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

The description states a specific verb ('Delete (discard)'), a specific resource ('your collection comment'), and even names the underlying mutation ('DiscardComment mutation via web session'). It clearly distinguishes from siblings like edit_collection_comment and post_collection_comment.

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 makes clear this deletes the user's own collection comment, which implies it is for comments the user authored. It doesn't explicitly name alternatives or exclusions, but the scope ('your collection comment') provides clear context for when to use it versus other comment tools.

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

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

Annotations already indicate destructiveHint=true and idempotentHint=true. The description adds meaningful context: it deletes 'all its replies' (scope of destruction) and explicitly states 'Cannot be undone' (irreversibility). This goes beyond the annotation flags and helps the agent understand the full impact of the action. No contradiction with annotations.

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

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

Two short sentences with no filler. The critical information (action, scope, permission, irreversibility) is front-loaded. Every word serves a 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?

The description covers the action, permission, and irreversibility, which are essential. However, it omits any mention of the dry_run parameter, which could be important for safe testing, and does not describe the return value or error behavior. Given the absence of an output schema, the description should have provided at least a note about the outcome or side effects. It is adequate for a basic call but incomplete for a tool with a dry-run option.

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

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

The description provides zero information about the parameters. The schema covers 50% of parameters (dry_run has a description, issue_id does not). Since schema coverage is moderate and the description does not compensate for the undocumented issue_id, the agent is left without guidance on what issue_id refers to or how it relates to the tool's function. This is a notable 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?

States a clear verb 'Delete' and a specific resource 'bug report and all its replies', along with scope ('from YOUR mod') and permission ('mod author/moderator only'). This differentiates it from sibling tools like reply_mod_bug and post_mod_bug, and even from hide_mod_comment. No ambiguity about what action is performed.

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?

Clearly identifies the intended user group (mod author/moderator) and the irreversible nature, implying it should be used only when permanent deletion is desired. However, it doesn't explicitly contrast with alternatives or mention when not to use it, such as when a less permanent moderation action (e.g., hiding) might be preferred. Still, the guidance is mostly clear and self-contained.

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

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

Annotations already declare destructiveHint=true, readOnlyHint=false, and idempotentHint=true. The description adds the crucial warning 'Cannot be undone,' which reinforces the destructive nature and adds value beyond the annotation. It also clarifies ownership ('YOUR mod'), implying authorization requirements. No contradiction with annotations.

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

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

Two sentences with no filler. The core action and the critical warning are front-loaded, and the reference to get_mod_media is placed exactly where it's needed. Every word earns its place.

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

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

For a destructive delete tool with no output schema, the description covers the essential behavioral context: what is deleted, ownership scope, irreversibility, and where to get the identifier. It doesn't describe the response format or error cases, but for a simple delete operation with annotations covering safety, this is adequate. The dry_run parameter is documented in the schema, so the description needn't repeat it.

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

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

Schema description coverage is 50%: game and image_id have descriptions, while mod_id and dry_run do not. The description adds meaning by explaining that image_id comes from get_mod_media, which is useful. However, it does not explain mod_id's role or the dry_run parameter's behavior beyond the schema's own description. The description partially compensates but doesn't fully cover the 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 states a specific verb ('Delete'), a specific resource ('an image from YOUR mod's gallery'), and a scoping constraint ('YOUR mod'). It also references the source of the required identifier ('image_id from get_mod_media'), which distinguishes it from other delete tools like delete_mod_bug or delete_collection_comment. The title and description align clearly.

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 it: when deleting an image from a mod gallery, and it names the source of the image_id (get_mod_media), which is a form of alternative/related tool guidance. It does not explicitly state when not to use it or mention alternatives like delete_mod_video, but the context is clear enough for an agent to select it correctly.

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

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

Annotations already mark this as destructive and non-read-only, so the bar is lower. The description adds the important behavioral detail 'Cannot be undone,' which reinforces the irreversibility beyond what destructiveHint alone conveys. No contradiction with annotations 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?

Two sentences, no filler. The core purpose is front-loaded, and the critical warning is separated clearly. Every word earns its place.

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

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

For a destructive delete operation with no output schema, the description provides the essential facts: scope, id source, and irreversibility. It could go slightly further by noting the behavior when the video_id does not exist or belongs to another mod, but the current text is 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 coverage is 60%, and the description adds meaningful semantics for video_id by referencing its source (add_mod_video / get_mod_media). It also implies that mod_id must refer to the caller's own mod. dry_run and video_type remain schema-documented but are not further explained.

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 video') and narrows the scope to 'YOUR mod', which clearly signals an author-owned action. It also tells the agent where to obtain a valid video_id, distinguishing this from image deletion tools like delete_mod_image.

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

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

The description gives clear context ('from YOUR mod') and tells the agent where video_ids come from, but it does not explicitly state when to prefer this tool over alternatives such as delete_mod_image. The usage guidance is implied rather than explicitly contrasted with 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?

Annotations already provide readOnlyHint=false, openWorldHint=true, idempotentHint=true, and destructiveHint=false. The description adds context about default directory (NEXUS_DOWNLOAD_DIR) and the premium/non-premium auth requirements. It doesn't describe failure behavior, overwrite policy, or authentication beyond the key/expires, but with annotations covering safety, the description adds modest value. No contradiction.

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

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

Two sentences, zero filler. The core purpose is front-loaded, and the premium/non-premium nuance is added efficiently. Every phrase earns its place.

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

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

For a tool with 6 parameters (3 required) and no output schema, the description covers the essential context: what it downloads, where it saves, and the auth requirements. It doesn't mention error handling or output format, but those are not critical for a download tool. It is complete enough for an agent to call correctly.

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

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

Schema coverage is 100% with each parameter described, so the baseline is 3. The description adds valuable context by explaining the relationship between premium/non-premium and the key/expires parameters, and clarifies dest_dir's default (NEXUS_DOWNLOAD_DIR). This goes beyond the schema's individual field 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 verb 'Download', the resource 'a mod file', and the destination (local directory with dest_dir or NEXUS_DOWNLOAD_DIR). It distinguishes from sibling get_download_link, which likely returns a link rather than performing a download, and from get_mod_file, which likely provides file metadata. The purpose is 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 the key difference between premium (direct download) and non-premium (requires key and expires from an nxm:// link), which guides parameter usage. It implies this tool is for actual downloading versus get_download_link, which likely returns a URL. However, it doesn't explicitly say 'use get_download_link if you only need the link', so the when-not-to-use guidance is 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?

Annotations already establish that this is a write operation (readOnlyHint=false), idempotent, and non-destructive. The description adds useful context by noting it operates 'via web session,' implying authentication requirements, and that it edits 'your' comment, implying an ownership restriction. But it does not disclose error behavior or what happens on success.

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 conveys the action, resource, scope, and implementation detail in compact form, 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?

For a simple two-parameter mutation with annotations covering safety and idempotency, the description is mostly adequate: it identifies the action and session requirement. However, with no output schema, the description does not mention the return value, and it leaves potential edge cases like editing a non-owned comment undocumented.

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 for parameter meaning. It does not explicitly explain that comment_id identifies the target comment or that body is the new text, though the plain property names and 'Edit your collection comment' make these meanings reasonably inferable. This is minimal added value 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 verb ('Edit'), the resource ('collection comment'), and the scope ('your'), distinguishing it from editing mod comments or posting new comments. Mentioning the underlying 'UpdateComment mutation' adds further precision without 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 tool is clearly for editing an existing collection comment, which implicitly separates it from siblings like post_collection_comment, delete_collection_comment, and edit_mod_comment. However, there is no explicit guidance about when to choose this tool over those alternatives or any stated prerequisites beyond 'web session.'

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

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

Annotations already indicate a non-read-only, non-destructive, idempotent operation. The description adds that the edit is limited to the caller's own comments and requires an authenticated web session, which is useful behavioral context beyond the annotations. It doesn't describe response behavior, but that is a minor gap here.

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 tight sentence that front-loads the action and object, then adds the identifier source and auth requirement. No filler or redundant restatement of the title.

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

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

The description covers the non-obvious requirements: ownership, authentication, and where comment_id comes from. It doesn't explicitly state the expected return value or that text is the full replacement comment body, but for a straightforward edit operation these are small omissions.

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%, so the description must compensate for the bare params. It clarifies comment_id's origin, but it leaves text, mod_id, and game largely implicit. The description does not fully bridge the gap left by the sparse 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?

States a specific verb ('Edit'), the resource ('your own comment on a mod's Posts tab'), and the identifier source ('comment_id from get_mod_comments'). This clearly distinguishes it from related tools like post_mod_comment, hide_mod_comment, and delete_mod_comment.

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 an explicit precondition ('Needs a logged-in web session') and points the agent to get_mod_comments for the required comment_id. It doesn't explicitly list alternatives such as edit_collection_comment, but the 'mod's Posts tab' and 'your own comment' wording sufficiently scope when this tool applies.

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

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

Annotations already establish readOnly=false, idempotentHint=true, and destructiveHint=false, so the description is not required to re-state those. It adds meaningful behavioral detail beyond the annotations: unchanged fields are resent exactly as loaded, and omitting all edit fields provides a view-only request. No contradiction with annotations 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 compact and front-loaded: the first sentence states the core purpose and editable fields, and each subsequent sentence adds necessary behavioral or usage information. There is no filler, and every sentence contributes to correct invocation.

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 7-parameter mutation with no output schema, the description covers the editable fields, preservation semantics, dry-run behavior, and view-mode behavior. It does not describe the response shape or explicit save confirmation, but given the rich annotations and clear parameter guidance, the remaining gap is minor.

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 57%, leaving name, mod_id, and version without schema descriptions. The description compensates by enumerating which fields are editable, clarifying that description is BBCode, and explaining that omitted optional fields are preserved rather than cleared. It does not add detail for version format, but the schema pattern already covers that constraint.

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

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

The description clearly specifies a verb ('Edit'), a resource ('YOUR mod page'), and the exact editable fields (name, summary, full description, version). It ties the behavior to the mod editor's Save action and distinguishes this tool from sibling comment-editing tools by making the author-scoped mod page resource explicit.

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 practical usage context: omitting all edit fields turns the call into a view of current values, and dry_run provides a preview. It does not explicitly list sibling alternatives or exclusion conditions, but the resource scope and field list make the intended use clear without needing an explicit 'when not to use' statement.

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

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

Annotations already declare readOnlyHint=false, openWorldHint=true, idempotentHint=true, and destructiveHint=false. The description adds the valuable behavior that the mod version is automatically resolved when omitted, which is not evident from annotations. It does not contradict any annotations, and the additional context about version handling is helpful for the agent.

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 conveys the core action and the key behavior (version auto-lookup). It is front-loaded with the primary purpose and contains no filler. Every word earns its place.

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

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

For a mutation tool with clear annotations (openWorld, idempotent, non-destructive) and no output schema, the description covers the essential call behavior. It does not detail return values or side effects, but the annotations and schema sufficiently cover the safety and parameter aspects. The only minor gap is lack of mention that endorsement requires authentication, but that may be implied by the tool context.

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

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

Schema coverage is 75% with all parameters documented: game, mod_id, action (enum+default), and version (with default behavior). The description's mention of automatic version lookup largely repeats the schema's 'defaults to the mod's current version'. It adds minimal new meaning beyond the schema, so a 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 clearly states the action (endorse or abstain) and the resource (mod), and adds the automatic version lookup. It distinguishes itself from read-only tools like get_endorsements and track_mod by indicating a state-changing action.

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

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

It notes that the current mod version is used if not given, which is a usage hint. However, it does not explicitly state when to prefer this over alternatives like track_mod or get_endorsements, nor does it mention any prerequisites (e.g., being logged in). The guidance is implicit rather than explicit.

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

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

Annotations already declare the operation as read-only, idempotent, and non-destructive, so the description need not repeat that. It adds value by stating 'Works without login' and enumerating the topic fields returned, which is useful because there is no output schema. Pagination and rate-limit behavior are not mentioned, but this is minor for a simple list 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?

Two dense sentences with no filler. The primary action is front-loaded, and the additional context about returned fields and authentication is compact and useful.

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

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

For a read-only list tool with no output schema, the description covers the main input modes, the auth expectation, and the returned topic fields. The unaddressed page parameter and lack of any return-structure detail leave a small but real gap, so it is not fully complete.

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

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

Schema description coverage is 50%: the forum parameter is documented in the schema, while page is not. The description reinforces forum input semantics by explaining the omit-for-index behavior, but it adds nothing about the page parameter, so the description only partially compensates for the schema 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 the specific verb 'List' with the resource 'sub-forums and topics of a forum' and clearly distinguishes the forum-index case from the targeted-forum case. This lets an agent differentiate it from siblings like forum_topic or forum_reply without opening their schemas.

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

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

The description gives clear call context: pass a forum_id or URL to list a specific forum, or omit the argument for the index, and notes login is not required. It does not explicitly name alternatives or when-not conditions, which prevents a 5.

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

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

Annotations already mark it as non-read-only and non-idempotent; the description adds useful context beyond that by disclosing the login requirement and SSO behavior. It does not detail failure behavior or duplicate-posting risk, but the annotation baseline lowers the burden.

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 concise sentences with no filler. The core action and identifier format are front-loaded, and the auth prerequisite is stated in the second sentence without extra 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 description covers the action, target identification, and the non-obvious SSO/auth prerequisite. It is sufficient for an agent to invoke the tool, though it could add a note about what happens when no session exists or that replies are publicly visible.

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 leaves 'topic' undocumented, and the description fills this gap by stating it accepts an id or URL. For text, html, and dry_run, the schema descriptions already carry the meaning, so the description wisely avoids repetition.

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 states a specific action ('Post a reply') and resource ('forum topic') and clarifies the identifier can be an id or URL. It is immediately distinguishable from sibling tools like pm_reply or reply_mod_bug because 'forum topic' names the exact target.

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

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

Usage context is implied: replying to a forum topic, with the prerequisite of a logged-in web session and automatic SSO. However, the description does not state explicit when-not-to-use conditions or alternatives such as reply_mod_bug or post_mod_comment.

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

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

Annotations already declare readOnlyHint=true and idempotentHint=true. The description adds useful behavioral context: 'Works without login' (auth not required) and '25 per page' (pagination size). No contradictions with annotations.

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

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

The description is two concise clauses, front-loading the core action and key details. No filler or redundancy.

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

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

For a simple read-only tool with no output schema, the description covers identification, pagination size, and auth requirement. However, it does not explicitly state how to navigate pages (e.g., 'use page parameter for later pages') or describe the return format, which could leave an agent uncertain about expected output. Given the simplicity, these are minor but noticeable 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?

Schema description coverage is 50% (topic has a description, page does not). The description reiterates topic format ('topic id or URL') already present in the schema, and mentions '25 per page' which implies pagination but does not explicitly explain the page parameter's role (e.g., default, how to get subsequent pages). It partially compensates for the missing page description but not fully.

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

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

The description states a clear verb ('Read') and resource ('posts of a forum topic'), with input specification (topic id or URL) and pagination detail. It is distinct from sibling tools like forum_list (which lists topics) and forum_reply (which posts replies), though it does not 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 implies its use case—reading posts—but does not explicitly state when to prefer this over siblings or mention exclusions. It is clear enough for a basic read operation, but lacks explicit alternative routing.

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

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

Annotations already declare readOnlyHint, openWorldHint, idempotentHint, and non-destructive behavior, so the description properly adds the ordering trait 'newest versions last' and the response shape 'version → entries'. However, the word 'All' is somewhat misleading given the schema's `last` parameter, which defaults to 20 and says 'Only the last N versions'. No annotation contradiction exists, but this mismatch reduces clarity.

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 compact, with no filler or redundant restating of schema fields. The core purpose and the most useful behavioral detail (ordering) are front-loaded in two short sentences.

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

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

For a simple read-only endpoint, this is largely complete: the schema documents all parameters, annotations cover the safety profile, and the description offers a minimal return-shape hint ('version → entries'). A small gap is that 'entries' is not further defined and the 'All' wording is not reconciled with the `last` default, but the schema compensates for that.

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

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

Schema description coverage is 100%, so the description does not need to re-explain `game`, `mod_id`, or `last`. The description adds no parameter-level detail beyond the schema, and it leaves unstated how 'All' interacts with the `last` limit.

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 title 'Get Mod Changelogs' plus the description clearly identifies the resource: all version changelogs of a mod. The 'version → entries' structure and ordering make the purpose unambiguous. It does not explicitly name sibling alternatives, but the resource is distinct from related tools like get_mod_file_versions and add_changelog.

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 the tool to use when you need a mod's changelog history, and it is clearly a read operation. However, it gives no explicit when-to-use guidance, no exclusions, and does not point to alternatives such as get_mod_file_versions or add_changelog.

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

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

Annotations already declare readOnlyHint=true, openWorldHint=true, idempotentHint=true, and destructiveHint=false, so the safety profile is fully covered. The description adds the detail that the mod list is optional, which is useful behavioral context, but it does not disclose anything else beyond the annotations.

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

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

A single sentence that front-loads the resource and return fields, with the optional flag clearly marked. Every word earns its place; no filler or repetition of the title.

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

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

For a read-only lookup with a single required parameter and no output schema, the description covers the essential return fields and the optional mod list. It does not describe pagination or the exact shape of the response, but given the tool's simplicity and the annotations covering safety, this is nearly complete.

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

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

Schema description coverage is 67%, with game and slug documented in the schema. The description adds meaning by clarifying that slug comes from the URL pattern and that list_mods controls whether the mod list is included, but it does not explain the game parameter's role or default behavior beyond what the schema already states. Baseline 3 is appropriate since the schema does most of the work.

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 ('get') and resource ('collection'), and enumerates the exact fields returned: author, stats, comment thread id, latest revision, and optionally the mod list. This clearly distinguishes it from sibling tools like get_collection_comments or search_collections, which serve different purposes.

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

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

The description implies usage by slug and mentions the optional mod list, but it does not explicitly state when to use this tool versus alternatives like search_collections or get_collection_comments. The context is clear enough for a straightforward lookup, but no exclusions or alternative routing are provided.

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

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

Annotations already mark this read-only, idempotent, and non-destructive, so the description does not need to restate safety. It adds useful behavioral context beyond the annotations: newest-first ordering, inclusion of first replies, and the GraphQL cursor pagination mechanism. It stops short of describing the return shape, but the annotations carry the main safety burden.

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?

Four short sentences, each carrying distinct information: what the tool reads, which identifiers to pass, how to paginate, and which sibling handles writes. Nothing is redundant.

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

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

The description covers the main read and pagination behavior and identifies the write alternative, but it omits the return shape and does not resolve the identifier requirement (whether comment_thread_id or slug is required, and which to prefer). For a 5-parameter tool with no output schema and no required fields, this leaves some ambiguity.

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

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

With only 40% schema description coverage, the description needed to compensate, and it does clarify comment_thread_id, slug, and after. However, it does not explain how game and first factor into the call, nor does it state that one of comment_thread_id/slug is required despite the schema listing no required fields.

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

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

The description opens with 'Read a collection's comments', a specific verb and resource that clearly distinguishes this from sibling write tools such as post_collection_comment, edit_collection_comment, and delete_collection_comment. It also adds ordering ('newest first') and scope ('with first replies'), making the tool's purpose unmistakable.

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

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

It gives explicit call guidance: pass comment_thread_id from get_collection or slug, and paginate with after equal to endCursor. It also names the write alternative, post_collection_comment, so an agent knows when not to use this read tool.

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

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

Annotations already cover read-only, idempotent, and non-destructive behavior. The description adds account-state nuance: premium vs non-premium handling and the exact nxm:// source for the optional credentials. It does not describe error cases or return shape, but the annotations carry much of the safety burden.

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: it opens with the core purpose, then states the two usage modes. Every sentence carries necessary information, and the nxm:// template is included without 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?

For a low-complexity, read-only tool with strong annotations and 100% schema coverage, the description covers the return concept and the main conditional behavior. It does not mention alternatives like download_file, but that is a minor gap given the rest of the structured context.

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

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

Schema coverage is 100%, so all five parameters are already documented in the schema. The description adds value by explaining when key and expires are actually required and by providing the nxm:// link template that shows how those values relate to game, mod_id, and file_id.

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 the resource clearly: 'CDN download URLs for a file.' It also explains the two invocation modes by premium status, so an agent understands what the tool returns. It does not explicitly differentiate from sibling tools like download_file or get_mod_files, so it is clear but not fully sibling-aware.

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

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

The description gives explicit conditional usage: premium callers work directly, while non-premium callers must pass key and expires parsed from an nxm:// link. This is actionable and precise. It does not mention alternatives or say when not to use this tool, but the context is clear enough.

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

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

Annotations already provide readOnlyHint, openWorldHint, idempotentHint, and destructiveHint, so the description does not need to repeat those. It adds a behavioral detail by specifying that the result includes both endorsed and abstained mods, which is beyond the tool name. However, it does not disclose what fields are returned, pagination, or whether both statuses are always included.

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 phrase with no filler words. It is efficiently written and front-loaded with the key information. It could be slightly more explicit about the action, but there is no redundancy.

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

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

For a simple read-only list tool with one parameter and no output schema, the description gives the essential meaning but omits usage context (e.g., whether it requires the current user's session, if it returns only mods the user has endorsed, and what the response shape is). Given the low complexity and annotations covering safety, it's minimally sufficient but not rich.

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 only parameter, 'game', is fully described in the schema with examples (skyrimspecialedition, fallout4, stardewvalley). Schema description coverage is 100%, so the description adds no new meaning about the parameter. It does not elaborate on how the game parameter filters the endorsement list.

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 resource (mods) and the specific filter (endorsed or abstained from), distinguishing it from general mod listing tools like list_mods. It's more specific than the name alone, though it doesn't explicitly say 'list' or 'get', relying on the title for that verb.

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 get_tracked_mods or endorse_mod. No mention of prerequisites, authentication requirements, or typical use cases. The description is purely declarative.

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

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

Annotations already declare readOnlyHint, openWorldHint, idempotentHint, and destructiveHint, so the safety profile is covered. The description adds minimal behavioral context beyond the return contents; it does not discuss auth, rate limits, or side effects. Given the annotations, the description is adequate but adds little extra behavioral detail.

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 fluff. The primary purpose is front-loaded, and the usage tip is concise. Every word adds value.

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

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

For a simple read tool, the description covers the input source (list_games) and the output fields. Without an output schema, it adequately describes the return structure. However, it does not clarify the effect of show_categories on the output, which is a minor gap given the boolean parameter.

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

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

Schema description coverage is 50% (only 'game' has a description). The description repeats the game parameter's purpose but does not explain 'show_categories', which has no schema description. The description mentions categories in the output but does not link it to the parameter, leaving the agent to guess how show_categories affects the result.

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 returns game details by domain name, listing specific fields (id, name, counts, categories). It distinguishes itself from siblings like get_mod (mods) and list_games (discovery) by its resource and scope. The verb 'get' and resource 'game' are explicit.

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

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

The description explicitly instructs using list_games to discover domain names, establishing a clear prerequisite flow. It does not explicitly mention when not to use it, but the guidance is sufficient for an agent to know this tool is for fetching details of a single game once the domain is known.

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

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

Annotations already convey the safety profile (readOnlyHint, idempotentHint, destructiveHint=false). The description adds a small but useful behavioral detail: the result includes the caller's own endorsement status, which implies an auth-dependent field. No contradiction exists, but no additional behavioral context beyond that is provided.

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 leads with 'Full mod info' and uses a colon list to enumerate fields. Each listed item is relevant and earns its place, though the list makes it slightly denser than strictly necessary.

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 read-only tool with safe annotations and no output schema, the field list effectively serves as the return contract. The main gaps are the absence of routing guidance toward sibling tools and no mention of whether the endorsement-status field requires authentication, though these are minor given the simple scope.

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%: both game and mod_id have descriptive text and examples. The description contributes no parameter-specific meaning beyond the schema, so the baseline score of 3 for high schema coverage applies.

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

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

The description states the verb 'get' and the resource 'mod', then enumerates the returned fields (name, version, author, status, downloads, endorsements, dates, summary, endorsement status). This makes the operation clear, though it does not explicitly differentiate it from the sibling get_mod_details, which likely overlaps 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 is given on when to use this tool versus alternatives like get_mod_details, get_mod_files, or get_endorsements. With several mod-related siblings, an agent must guess which tool to invoke, since the description only states what the tool returns, not when it is the right choice.

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

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

Annotations already declare readOnlyHint=true, idempotentHint=true, and destructiveHint=false, covering the safety profile. The description adds value beyond those hints by specifying that the operation returns both the bug report and its replies, which is meaningful behavioral scope. No contradictions with annotations.

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

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

One efficient sentence with no filler. The core action and scope are front-loaded, and the parameter provenance is appended naturally. Every word earns its place.

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

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

For a one-parameter, read-only tool with strong annotations, the description is complete: it identifies the input source, the operation, and the expected content (report plus replies). No output schema exists, but the description's statement of what is read effectively communicates return scope.

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%, so the description carries the burden. It names the single parameter (issue_id) and, more importantly, tells the agent where to obtain it (from get_mod_bugs), which is the key semantic context needed to call this tool correctly. It doesn't over-explain the simple integer type.

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 ('Read') and resource ('one bug report and its replies'), clearly distinguishing this single-issue read from sibling tools like get_mod_bugs (list) and reply_mod_bug/delete_mod_bug (mutations). The parenthetical 'issue_id from get_mod_bugs' further anchors the exact resource.

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 concrete usage context: it tells the agent that the issue_id parameter comes from get_mod_bugs, implying a list-then-fetch workflow. It doesn't explicitly state when not to use this tool versus alternatives, but for a simple read tool with one parameter, this is sufficient guidance.

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

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

Annotations already cover readOnlyHint, openWorldHint, idempotentHint, and destructiveHint, so the safety profile is known. The description adds beyond annotations by specifying pagination ('10 per page') and the authentication nuance ('private reports need the author's session'), both of which are useful behavioral details not captured in the schema or annotations.

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

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

The description is concise and front-loaded. Each sentence adds value: purpose, fields, pagination, and auth requirements. No filler or redundancy. The structure is easy to scan and directly supports agent decision-making.

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 read-only list tool with no output schema, the description covers key aspects: it lists the returned fields, states pagination (10 per page), and notes authentication requirements. It does not describe error conditions or how to filter by status, but those are partly in the schema. Overall, it is reasonably complete for an agent 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 only 25% (only 'game' has a description), so the description should compensate for the undocumented parameters. It does not explain mod_id, page, or status semantics; the only hint is '10 per page', which indirectly relates to pagination but does not clarify parameter usage or the meaning of the status enum. The listed output fields are helpful but not 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 states a specific verb ('List'), resource ('a mod's bug reports'), and clarifies it refers to the Bugs tab. It also enumerates the returned fields (id, title, status, replies, version, priority, last post), which makes the tool's scope unmistakable and distinguishes it from the singular get_mod_bug sibling.

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 useful context about authentication ('Works without login') but does not explicitly say when to prefer this tool over get_mod_bug or other bug-related siblings. It implies usage via the plural 'bug reports' but lacks explicit guidance on alternatives or conditions that would select a different 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?

Beyond the readOnly/openWorld/idempotent annotations, the description adds meaningful behavior: sticky threads are returned first, pagination is fixed at 10 threads per page, and no login is required. This gives an agent actionable expectations about ordering, pagination, and auth.

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

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

Three short sentences deliver the core purpose, return contents, ordering, pagination, and auth context with no filler. Key constraints are front-loaded and every sentence earns its place.

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

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

With no output schema, the description carries the return-shape burden and does so well: it lists the comment fields, nested replies, ordering, pagination, and auth requirement. For a read-only paginated list tool, this is sufficient 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 only 33%, so the description needed to compensate for the undocumented mod_id and page parameters. It implies mod_id via 'mod page's' and hints at page via '10 threads per page,' but it never directly explains either parameter or the page default. 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 names a specific verb ('Read'), a precise resource ('a mod page's Posts tab'), and the data shape (threaded comments with id, author, date, text, inline replies). This clearly distinguishes it from write/comment mutation siblings like post_mod_comment or edit_mod_comment.

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

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

The intended use is clear: to read the Posts tab comment threads. It also notes that login is not required, which sets expectations. It does not explicitly name alternatives or exclusions, but the read-only framing makes it obvious relative to the mutation siblings.

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

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

Annotations already cover read-only, open-world, idempotent, non-destructive behavior. The description adds value by disclosing that the description is returned as raw BBCode 'as stored' (not rendered or sanitized), and that uid is included specifically for v3, which affect downstream handling. No contradiction with annotations present.

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 that front-loads the key differentiator ('without an API key') and then lists the included fields in order. No filler, no repetition of schema content, and every phrase 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?

With no output schema, the description carries the burden of explaining return contents, and it does enumerate the main fields plus the BBCode caveat. However, the structure of requirements/mods-requiring-it and error behavior for invalid mod_id are left unspecified, and the include_description toggle is only discoverable in the schema.

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

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

Schema documentation covers only 'game' (33% coverage); mod_id and include_description lack schema descriptions. The tool description implies include_description's effect by promising the 'full description', and mod_id is reasonably clear by name, but the description does not directly explain parameter behavior or formats, leaving the coverage gap only partially compensated.

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

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

The description names a specific verb (get) and resource (mod info) and enumerates the payload: full BBCode description, tags, uid, requirements, and mods requiring it. The 'without an API key' phrase plus the GraphQL title help distinguish it from sibling getters like get_mod, though it never explicitly contrasts with get_mod or list_mods.

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?

'Without an API key' gives implied context for when to choose this tool, but there are no explicit when-to-use/when-not-to-use instructions and no named alternatives. The agent must infer that other tools are the alternatives when an API key is available.

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

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

Annotations already declare readOnlyHint=true, idempotentHint=true, and destructiveHint=false, so the safety profile is covered. However, the description adds no behavioral context beyond that—no mention of what 'details' includes (e.g., file size, upload date), no note on error conditions (e.g., file not found), and no hint of return structure. Given no output schema exists, the description fails to compensate.

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

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

The description is concise (one short phrase), but it is under-specified rather than efficiently structured. It lacks any front-loading of key constraints or context. While brevity is a virtue, it is not paired with the informational density expected for a useful tool description.

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

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

For a tool with three required parameters and no output schema, the description is inadequate. It does not explain the nature of 'details' (e.g., whether it returns metadata, download URLs, or version history), nor does it mention any associated operations or error handling. An agent would need to call the tool or inspect sibling tools to understand what it returns.

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 each parameter (game, mod_id, file_id) having a clear description. The tool description adds no additional semantics—it only says 'Details for one mod file,' which does not clarify parameter usage beyond what the schema already provides. Baseline 3 applies because the schema handles 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 states a clear verb-resource pair ('get' a mod file) but the object is vague: 'Details' gives no specificity about what kind of details (metadata, download info, changelog). It does not distinguish from sibling tools like get_mod_files (list) or get_mod_file_versions (version list), both of which 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 is provided on when to use this tool versus alternatives. The description merely says 'Details for one mod file' with no mention of prerequisites (e.g., obtaining file_id via get_mod_files), no contrast with get_mod_files or get_mod_file_versions, and no exclusion criteria. The agent must infer usage entirely from the schema and name.

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

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

Annotations already declare readOnlyHint=true, openWorldHint=true, idempotentHint=true, and destructiveHint=false, covering the safety profile. The description adds the specific output fields but does not disclose potential behaviors like pagination, ordering, or limits. For a read-only list tool, the annotations lower the bar, and the field enumeration adds modest value, but behavioral details are sparse.

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

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

The description is a single, well-structured sentence that leads with the primary action and resource, then lists the output fields, and ends with the optional filter. Every word contributes value, with no filler or redundancy.

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

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

There is no output schema, so the description compensates by explicitly listing the returned fields. The three parameters are all described in the schema, and the tool's complexity is low. It might have mentioned pagination or result ordering, but for a straightforward list operation, the information provided is nearly sufficient for an agent 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 description coverage is 100%, so all three parameters (game, mod_id, category) are fully documented in the schema. The description only reiterates the optional category filter, which adds no new meaning beyond the schema's enum description. The baseline of 3 is appropriate because the schema handles the 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 ('List'), the resource ('a mod's files'), and explicitly enumerates the returned fields (file_id, name, version, category, size, upload date). It also notes the optional category filter. This is specific and unambiguous, distinguishing it from single-file tools like get_mod_file or version-history tools like get_mod_file_versions.

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 get_mod_file, get_mod_file_versions, or list_mods. It does not mention exclusions or prerequisites. While the tool's purpose is clear, an agent has no explicit direction for choosing it among the many file- and mod-related siblings.

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

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

Annotations already declare readOnlyHint, openWorldHint, idempotentHint, and destructiveHint, covering safety. The description adds the fields that will be returned, which is useful, but does not disclose any other behavioral details such as sorting, pagination, or error conditions. It adds a modest amount beyond annotations.

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

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

The description is a single concise sentence that front-loads the core purpose and lists the key fields. There is no extraneous information, 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?

With no output schema, the description compensates by listing the fields returned. It is sufficient for a simple read operation with a single parameter, though it does not mention potential pagination or response format, which would be nice but not critical given the tool's simplicity.

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 100% of the parameter description, including the mod_file_id and its source (get_upload_targets). The description does not add any additional semantic meaning beyond the schema, so a baseline score of 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 clearly states the tool's function: listing versions of a specific v3 mod file, and enumerates the returned fields (id, version, category, upload date, primary). This distinguishes it from sibling tools like get_mod_file (single file) and get_mod_files (file list for a mod).

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 explicit guidance is provided on when to use this tool versus alternatives. The description only states what it does, without mentioning context or exclusions. The usage is only implied by the tool name and description.

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

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

Annotations already cover read-only, open-world, and idempotent behavior. The description adds meaningful context by specifying the auth/session requirement and the editor-specific presentation of the media list, which is beyond what the annotations or schema communicate.

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 packs the action, the resource, the included fields, the view context, and the auth requirement with no filler. The most important scoping information ('author images and videos') 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?

This is a simple read-only list operation with two straightforward parameters and no output schema. The description conveys the returned media fields, the editor context, and the required session, so an agent has enough to select and 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 50%: game has an example, but mod_id has no description. The tool description does not explain either parameter further, relying largely on the tool name and schema types. This is acceptable but not a strong compensation for the undocumented mod_id.

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 ('a mod's author images and videos'), and clarifies the editor-facing view with 'as the mod editor shows them.' This clearly distinguishes it from sibling tools that upload or delete media, and from get_mod which returns broader mod data.

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

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

It states the required session context ('Author/editor session required'), which tells an agent when it can be used. It does not explicitly name alternatives or give a 'when not to use this' condition, but the editor-scoped phrasing makes the intended use clear.

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

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

Annotations already convey the safety profile with readOnlyHint and idempotentHint, so the description does not need to repeat that. It adds minimal behavioral context by saying 'Latest' (implying chronological ordering) and 'optionally per game/category' (indicating filtering behavior), but it does not disclose return format or pagination. No contradiction exists.

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

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

The description is a single nine-word sentence that is front-loaded and free of filler. Every word adds meaning, making it highly scannable and efficient for an agent to parse.

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

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

With three optional parameters and no output schema, the description omits count semantics, fails to clarify the category enum values, and offers no usage guidance. Annotations cover safety, but an agent still must guess at count behavior and expected return shape, making the description incomplete 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 description coverage is only 33%, and the description merely mentions 'per game/category' without explaining the count parameter or the meaning of category enum values. It partially compensates for game and category but leaves count's role as the number of news items to inference, so it does not adequately cover the low schema coverage.

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

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

The description states a specific verb-resource pair: it retrieves 'Latest Nexus Mods news' with optional filters 'per game/category'. It is clearly distinguishable from sibling tools because none of the other siblings target news, and the title 'Get News (GraphQL)' reinforces the dedicated purpose.

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

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

The description provides no guidance on when to use this tool versus alternatives such as the generic graphql_query or list_mods. It only states what the tool does, without explicit context, prerequisites, or exclusion conditions, leaving the agent to infer when it should be selected.

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

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

The annotations already declare readOnlyHint, openWorldHint, idempotentHint, and destructiveHint=false, so the safety profile is covered. The description adds a small behavioral detail about the returned tuple shape, but it does not address empty results, authentication needs, pagination, or other runtime behavior.

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

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

The description is extremely concise, front-loading the core purpose and adding the optional-filter detail in a single sentence. There is no filler, repetition, or unnecessary 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 simple read-only listing tool with one optional parameter and robust annotations, the description is largely complete. The parenthetical defines the output shape in place of an output schema; one could ask for explicit mention of authentication or empty-result behavior, but these are not critical gaps given the tool's low 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 description coverage is 100%, so the schema fully documents the only parameter, 'game', with an example value. The description merely restates that the game parameter is optional, adding no semantic detail beyond what the schema already provides.

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

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

The description clearly states the resource ('mods you track') and the optional game filter, and the parenthetical '(game domain + mod id)' clarifies the shape of what is returned. It is more specific than a tautology and is distinguishable from the sibling list_mods by the 'tracked' scope, though it does not explicitly name that 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?

The description implies when to use this tool: when you want to see mods the user tracks, with an optional game filter. However, it provides no explicit guidance about when to choose this over siblings like list_mods or track_mod, and no exclusions or prerequisites 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?

Annotations already declare readOnlyHint, openWorldHint, idempotentHint, and destructiveHint=false, so the agent knows this is a safe, read-only operation. The description adds the detail that results include timestamps, which is not specified in the schema or annotations. This is helpful but limited—no mention of pagination, rate limits, or error cases. Given the strong annotation coverage, a 3 is appropriate.

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

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

A single sentence that front-loads the core purpose and includes a direct usage hint. There is no fluff or redundancy; every word is useful. The structure is ideal for quick agent parsing.

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 read-only, idempotent tool with no output schema, the description adequately covers the essential return value (IDs and timestamps) and the intended use case. It does not mention how to handle pagination with 'limit' or the exact format of timestamps, but these are minor gaps given the tool's simplicity and the annotation coverage. It is nearly complete.

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

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

Schema description coverage is low (33%), with only 'game' having a description. The description implicitly maps the 'period' enum to 'last day/week/month' but does not explicitly name the parameter or explain 'limit' or the default. It adds some value for 'period' but leaves 'limit' and 'game' (already described) untouched. The description does not fully compensate for the schema's lack of 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 tool's function: it returns IDs of mods updated in a given time period (day/week/month), with timestamps. The verb 'get' and resource 'updated mods' are specific, and the period options are explicitly mentioned. It distinguishes itself from siblings like list_mods (all mods) and get_mod (single mod) by focusing on recently updated mods.

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

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

The description provides a concrete use case: 'Use to check tracked mods for updates.' This tells the agent when to use the tool. However, it does not explicitly mention alternative tools or state when NOT to use it, leaving some ambiguity. Still, the given context is clear enough for most agents.

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

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

Annotations already declare readOnly, idempotent, and non-destructive behavior. The description adds useful context beyond that: it performs a resolution from site-facing IDs to v3 IDs and returns a list of file IDs. This clarifies that the tool is a preparatory mapping step with no side effects, consistent with the annotations.

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

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

One short, front-loaded sentence contains all essential information without redundancy. It states the action first, then the output, then the downstream purpose—every clause earns its place.

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

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

For a read-only, two-parameter lookup with no output schema, the description covers what inputs are needed, what is returned, and why it matters. The exact result structure is not specified, but the named downstream consumers make the expected shape inferable, and annotations handle the safety profile.

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

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

Schema description coverage is 0%, so the description carries the full burden. 'game + mod_id from the site URL' gives provenance and meaning to both parameters, explaining they come from the URL rather than being arbitrary values. It does not spell out exact URL structure, but this is sufficient for the two simple 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 names a specific action ('Resolve a mod... to its v3 mod uid and list its mod files') and identifies the exact downstream consumers ('the ids upload_file_version and add_changelog need'). This makes it clearly distinct from broader sibling tools like get_mod_files or get_mod, even without an explicit alternative 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?

The description implies when to use the tool: before upload_file_version or add_changelog to obtain required IDs. However, it does not explicitly say when not to use it or name alternative tools for similar lookups (e.g., get_mod_files), leaving the boundary between sibling tools 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?

Annotations already cover readOnlyHint, openWorldHint, idempotentHint, and destructiveHint, so the description doesn't need to repeat those. It adds behavioral detail by enumerating the returned fields, which is useful for the agent to know the output shape. No contradictions with annotations; the 'public profile' wording implies no auth or mutation.

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

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

The description is a single sentence that front-loads the key purpose ('Public profile by username') followed by a compact list of return fields. Zero redundancy, every word earns its place.

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

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

For a simple tool with one parameter and no output schema, the description is complete. It states what it does, the parameter semantics, and the return contents. Annotations cover the safety profile, so nothing an agent needs to call it correctly is missing.

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

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

The schema provides only the parameter name 'name' with no description, so coverage is 0%. The description compensates by clarifying that the parameter is a username ('by username'), which is essential for correct usage. It doesn't add further format details (e.g., case sensitivity), but for a single string param, this is sufficient.

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

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

The description clearly states the action (get) and the resource (public profile) keyed by username. It lists specific return fields (member id, join date, kudos, mod/collection counts, about) and distinguishes from siblings like validate_user or get_mod by focusing on public profile data.

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

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

The description provides clear context for when to use: when you need a user's public profile by username. It doesn't explicitly mention alternatives or exclusions, but the purpose is so specific that an agent can infer the appropriate use case. No explicit comparison to validate_user or other user-related tools is given, which is a minor gap.

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

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

Annotations already declare readOnlyHint, idempotentHint, and destructiveHint=false, and the description adds valuable behavioral context beyond them: mutations are rejected, output is raw JSON, and the GraphQL schema URL is provided. No contradictions exist between the description and annotations.

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

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

The description is exceptionally concise and front-loaded, with the core action, endpoint, and critical constraint stated in the first sentence. The second sentence adds output format and usage preference without any 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 open-world nature of a raw GraphQL tool, the endpoint and schema URL provide solid grounding, and annotations cover the read-only safety profile. The main gap is the absence of parameter-level guidance, particularly for the optional 'variables' parameter, though the simplicity of the schema partially compensates.

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 explains nothing about the 'query' or 'variables' parameters. The GraphQL schema URL helps an agent understand valid query syntax, but the description itself does not clarify how variables map to GraphQL variables or how to structure the query object.

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 action ('Run any read-only query'), the exact GraphQL endpoint, and the explicit constraint that mutations are rejected. It also distinguishes this raw query tool from the typed sibling tools by its raw JSON output and open-ended GraphQL nature.

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

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

The description gives clear context for when this tool is appropriate: arbitrary read-only GraphQL queries that the typed tools don't cover. It states that mutations are rejected and instructs the agent to 'prefer the typed tools,' providing usable selection guidance, though it doesn't name a specific alternative 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?

While annotations already mark the tool as destructive and non-read-only, the description adds valuable context about the actual behavior: it removes a comment from view for everyone except staff调和. It also discloses authorization limits ('mod's author for any comment on their mod') and session requirements, which go beyond the annotation hints. No contradiction with the annotations.

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

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

The description is compact and front-loaded: it states the action and target in the first phrase, then immediately gives the behavioral effect and constraints. Every sentence provides necessary information 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?

For a mutating tool with no output schema, the description covers the essential operational context: what the action does, its visibility effect, permission scope, and the need for a logged-in session. It doesn't mention response behavior, but dry_run and report parameters are adequately described in the schema, and the missing output docs 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 coverage is 67% and the description does not add much parameter-level detail beyond the schema. It echoes the optional report behavior through 'optionally report', but does not clarify the meaning of game, mod_id, or comment_id beyond their names. The missing mod_id and comment_id descriptions are not compensated, though the parameter names are reasonably self-explanatory.

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: 'Hide a comment on a mod's Posts tab', and clarifies the action is the site's 'Hide and optionally report post' action. It also states the effect ('removes it from view for everyone except staff'), making the purpose concrete and distinct from editing or deleting comments.

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 identifies the intended context: hiding comments on a mod's Posts tabais, and specifies that it is available to the mod's author for any comment on their mod. It also notes the prerequisite of a logged-in web session. It doesn't explicitly name alternatives like edit_mod_comment or delete_mod_comment, but the conditions are clear enough to select this tool.

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

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

Annotations already establish read-only, idempotent, open-world, non-destructive behavior. The description adds value beyond these annotations by stating that no API key is needed and that the returned domain names are the scoping values downstream tools depend on.

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 filler. The core purpose is front-loaded, followed immediately by the most relevant auth fact and workflow 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 simple list/find tool with zero required parameters and safety annotations, this covers purpose, output substance, workflow usage, and auth requirements. The absence of an output schema is mitigated by explicitly naming what is returned.

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 documents 'query' as a partial game name and constrains 'count' with defaults/min/max, so the description adds no parameter-level meaning. 'count' lacks a prose description, but its constraints make it reasonably inferable; a brief mention would have improved the 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?

States a specific action ('Find games') and a concrete output ('their domain names'), and frames it as the prerequisite for all game-scoped tools. This clearly distinguishes it from get_game and the search-focused siblings.

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 tells the agent when this tool should be used: before any game-scoped tool, since it supplies domain names those tools need. It lacks explicit discussion of alternatives or when not to use it, which keeps it from a 5.

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

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

Annotations already declare readOnlyHint, openWorldHint, idempotentHint, and destructiveHint false, covering safety. The description adds the 10-mod limit, which is useful, but does not describe the return format, pagination, or ordering semantics beyond the enum names. It neither contradicts nor substantially expands beyond annotations.

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

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

A single, front-loaded sentence conveys the core behavior and the key limit. No wasted words, and the most important constraint (10 per list) appears first.

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

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

For a simple read-only list tool, the description covers the required parameters and the output count, but it does not explain the meaning of the list types, the return structure, or how it differs from get_updated_mods. With no output schema and only 50% schema coverage, a bit more context would be needed for full agent confidence.

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

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

Schema description coverage is 50%: 'game' has a descriptive explanation, but 'list' only has an enum with no per-value semantics. The description repeats the enum values without explaining what each means (e.g., what 'trending' is based on). It adds marginal value over the schema but does not fully compensate for the missing list 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 states the verb ('list') and the resource ('mods') and specifies three list types. It is clear but does not differentiate from siblings like get_updated_mods, which overlaps in purpose. It lacks an explicit statement of what it is not.

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

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

The description implies usage by enumerating the three list types and the 10-mod limit, but gives no guidance on when to choose this over alternatives like get_updated_mods. There is no 'when not to use' or mention of 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?

Annotations already declare readOnlyHint=true, idempotentHint=true, and destructiveHint=false, so the safety profile is covered. The description adds the return behavior ('returns mod + file') which is useful context beyond the annotations. No contradictions found.

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 zero fluff. The purpose is front-loaded, and the alternative usage is stated concisely. Every word contributes to clarity and routing.

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 lookup tool with no output schema, the description covers the essential purpose, input, and alternative. It does not describe error handling or multiple-match behavior, but these are minor for a read-only lookup. The annotation set and schema fill most 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?

Schema description coverage is 100%, so both parameters (md5 and game) are already fully documented in the schema. The description does not add any parameter-specific guidance, which aligns with the baseline of 3 when the schema carries the load.

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 'identify', the resource 'mod file', the input 'MD5 hash', and the output 'mod + file'. It also distinguishes itself from sibling tools by explicitly naming graphql_query for batch operations, so an agent can tell them apart without opening schemas.

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

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

The description provides an explicit usage boundary: use this tool for a single hash, and for a batch of hashes use graphql_query with fileHashes. This directly addresses when to use this tool vs an alternative, leaving no ambiguity.

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

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

Annotations already mark the operation as destructive and non-read-only. The description adds useful behavioral context by specifying the exact consequence: the conversation is removed from the inbox and permanently deleted once no participants remain. This goes beyond the structured hints without contradicting them.

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

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

A single sentence that front-loads the action and consequence, with a useful parenthetical and implementation note. No filler or redundancy.

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

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

For a simple two-parameter destructive action, the description plus schema and annotations provide enough to call it correctly. It covers the core consequence and deletion condition, though it does not mention return values or failure behavior, which is a minor gap given there is no output schema.

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

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

Schema coverage is only 50%: dry_run is described, but conversation_id is not. The tool description does not explicitly explain conversation_id, though its name and the phrase 'private conversation' make its purpose reasonably inferable. The description adds minimal parameter-level value 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?

States a specific verb ('Leave') and resource ('private conversation'), and goes beyond the title by explaining the effect: removal from the inbox and deletion once no participants remain. This clearly distinguishes it from sibling tools like pm_send, pm_read, and pm_reply.

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 makes the intended use obvious by naming the action and its effect, but it does not explicitly state when to choose this tool over alternatives or mention exclusions. The context is clear, but no direct routing guidance is provided.

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

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

Annotations already declare readOnlyHint, idempotentHint, and destructiveHint, so the safety profile is known. The description adds useful behavioral context by specifying the need for a logged-in session and enumerating the return fields. It does not contradict annotations and provides value beyond the structured metadata.

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

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

The description is two short sentences with no filler. It front-loads the primary purpose and return fields, then adds the session requirement. Every word contributes to understanding the tool.

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

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

The description covers the essential aspects: what it lists, the return fields, and the session requirement. However, it omits any mention of the page parameter or how pagination works. Given the tool's simplicity and the presence of an output-less schema, this is a minor gap but not critical for basic usage.

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 description coverage is 0%, meaning the page parameter is completely undocumented in the schema. The description does not mention pagination or explain the page parameter at all, leaving the agent to infer its purpose from the name and default value. This is a significant gap for a tool with a pagination 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 verb 'List' and the resource 'private-message conversations', specifying the exact fields returned (id, title, participants, last message snippet, unread flag). It distinguishes itself from sibling pm_* tools (pm_send, pm_reply, pm_leave, pm_read) by focusing on listing conversations, making its purpose unambiguous.

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

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

The description notes a prerequisite (logged-in web session) but does not explicitly mention when to use this tool versus alternatives like pm_read or pm_send. The distinction is implied by the action of listing, but there is no direct guidance on selection criteria or exclusion conditions.

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

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

Annotations already declare readOnlyHint, idempotentHint, and destructiveHint, so the safety profile is covered. The description adds valuable behavioral details beyond annotations: pagination at 25 messages per page and the requirement of a logged-in web session. This supplements the structured metadata without contradicting it.

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

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

The description is two short sentences with no filler. The core action and resource are front-loaded, and the pagination and session requirements are stated efficiently. Every sentence earns its place.

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

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

For a simple read tool with two parameters, the description covers the key operational facts: how to identify the conversation, pagination behavior, and authentication requirement. The lack of an output schema is acceptable because the description clearly says it reads messages, so an agent can infer the return content. Minor missing details like ordering are not essential.

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 for parameter meaning. It clearly explains conversation_id as 'id from pm_list,' which is helpful. However, the page parameter is only indirectly implied by '25 per page' and is not explicitly described as the page number to request. This is partial compensation but not complete.

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

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

The description states a specific action and resource: 'Read the messages of a private conversation.' It also references pm_list for obtaining the conversation id, which distinguishes this tool from pm_send, pm_reply, pm_leave, and pm_list. The title 'Read Private Conversation' reinforces the same resource without 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 gives clear usage context by specifying that it reads a private conversation and that the conversation id comes from pm_list. It also states the requirement of a logged-in web session. It does not explicitly discuss when not to use it or directly name alternatives, but the context is sufficient for an agent to route correctly.

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

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

Annotations already signal a non-read-only, non-idempotent write, so the description's job is lighter. It adds the auth prerequisite and the 'existing conversation' constraint, which is useful, but it does not disclose side effects like duplicate sends or response behavior. This is adequate but not rich.

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

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

Two short sentences with no filler. The main verb and resource are front-loaded, and the parenthetical adds the essential id-source guidance immediately.

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 with four parameters and no output schema, the description covers the critical preconditions: the conversation must already exist, the id comes from pm_list, and a logged-in web session is required. It does not describe return values or error cases, but the schema handles parameter-level details, making this nearly complete.

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

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

The description adds the key source for conversation_id ('id from pm_list'), which is not in the schema. The schema already documents text and dry_run, and the text property's description covers html behavior. However, with schema coverage at 50%, the description only partially compensates for the less-documented 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 specific action ('Reply') on a specific resource ('existing private conversation') and tells the agent where to get the conversation id (pm_list). This clearly differentiates it from new-message or read-only private-message 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 clear context: use it only for existing conversations, get the id from pm_list, and ensure a logged-in web session. It does not explicitly name pm_send as the alternative for new conversations or state exclusions, so it stops short of a 5.

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

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

Annotations already cover mutating, non-idempotent, non-read-only behavior, so the description's addition of the 'logged-in web session' requirement adds useful behavioral context. It does not contradict annotations and gives a prerequisite that an agent must know before invoking the 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, front-loaded sentence that states the core action and a key prerequisite. There is no wasted wording, and it 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?

For a mutation tool with no output schema and several parameters, the description is too minimal. It omits any mention of what happens after sending, expected return values, or specifics about the optional parameters (html, dry_run). The session requirement is the only added context, leaving many operational details unaddressed.

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 60% (to, text, dry_run have descriptions; title and html do not). The description adds no parameter-specific details, failing to compensate for the undocumented title and html parameters. An agent must infer their meaning from names alone, which is insufficient.

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

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

The description clearly states the action: 'Start a new private conversation' with one or more members, and distinguishes it from reply operations by using 'new'. The title also clarifies the resource. This differentiates it from pm_reply and other siblings without requiring schema inspection.

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

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

The description provides clear context by specifying 'new private conversation' and the forum messenger compose context, which implies it is for initiating rather than replying. However, it does not explicitly name alternatives like pm_reply or state when not to use it, so it lacks explicit exclusion guidance.

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

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

Annotations already signal this is a write operation. The description adds useful behavioral context by stating it 'Uses the site's CreateComment mutation with the web session', which discloses the implementation mechanism and an authentication prerequisite. No contradiction with annotations.

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

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

Two concise sentences deliver the core purpose and the key implementation detail with no filler. The purpose is front-loaded, and every phrase earns its place.

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

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

For a simple write operation with no output schema, this description is adequate but not complete. It omits any mention of what the tool returns on success or failure, and does not explicitly state whether replies require comment_thread_id as well, leaving some uncertainty for an agent.

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 is the only source of parameter meaning. It clarifies that comment_thread_id comes from get_collection and that reply_to_id is used for replies, but it leaves body's role implicit and does not explain the relationship between reply_to_id and comment_thread_id in a reply scenario.

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: 'Comment on a collection' or 'reply', and even names the source of the comment_thread_id (get_collection). This clearly distinguishes the tool from post_mod_comment and other collection-related siblings.

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

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

It explains when to use the tool: to comment on a collection or reply to an existing comment, and identifies where comment_thread_id comes from. However, it does not explicitly exclude alternatives like post_mod_comment or edit_collection_comment, so the guidance is clear but not fully exhaustive.

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

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

Annotations already communicate that this is a non-read-only, non-idempotent mutation. The description adds genuinely useful behavioral context beyond those annotations: BBCode is allowed in the report body, and an authenticated web session is required. It does not disclose secondary effects such as notifications, but it covers the key runtime prerequisite.

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 short sentences with no filler. The primary purpose is front-loaded, and the two supporting details (BBCode, login requirement) each add real value without bloating the text.

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 straightforward creation tool, the description covers the action, the UI location, formatting rules, and the critical authentication prerequisite. The input schema handles parameter constraints, and since there is no output schema, the description is not obligated to detail the return value. A small gap is that it never says what indicates success, but this is not blocking.

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 50%, and the tool description does little to compensate. It mentions BBCode, which relates to text/title, but it does not clarify the meaning of mod_id, title, text, or the relationship between game and mod_id. The schema describes game, dry_run, and private, but leaves title, text, and mod_id undocumented in both places.

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: 'File a new bug report on a mod' with the UI location '(Bugs tab → Report a bug)'. The word 'new' clearly distinguishes it from sibling tools like reply_mod_bug or delete_mod_bug.

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

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

It provides a clear usage context: you use this when you want to file a new bug report, and it names the precondition 'Needs a logged-in web session'. It does not explicitly contrast with reply_mod_bug or get_mod_bugs, but the action described is unambiguous enough to route an agent correctly.

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

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

Annotations already indicate a non-read-only, non-idempotent, non-destructive operation. The description adds meaningful behavioral context: a logged-in web session is required and BBCode is allowed. This goes beyond the annotations, though it stops short of explaining error handling or visibility 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?

Two sentences with zero filler. Each sentence carries distinct value: the core action, the reply mechanism, the session requirement, and formatting info. Everything 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 write operation with no output schema, the description provides the essential invocation details: what to post, where, how to reply, auth, and formatting. It does not mention return values, but that is not critical when no output schema exists.

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

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

Schema description coverage is 50%; the schema describes game and parent_id but not text or mod_id. The description compensates by explaining that parent_id is the comment id from get_mod_comments and that BBCode is allowed in text. mod_id is left undocumented, but it is relatively self-evident in 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 a specific verb ('Post') and resource ('comment on a mod's Posts tab'), and clearly covers the reply case by referencing parent_id from get_mod_comments. This distinguishes it well from siblings like post_collection_comment and forum_reply.

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

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

It clearly states where to post (mod's Posts tab) and how to reply (using parent_id from get_mod_comments), and it notes the auth prerequisite. It does not explicitly name alternatives or say when not to use it, but the context is sufficiently clear for an agent to select it.

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

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

Annotations already indicate a write operation (readOnlyHint false) and non-destructive (destructiveHint false). The description adds the requirement of a logged-in web session, which is not in annotations, and notes BBCode is allowed. This provides useful behavioral 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 two sentences, front-loaded with the action and source, with no wasted words. It is efficient and scannable, covering the essential points without redundancy.

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

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

For a simple reply tool with three parameters and no output schema, the description covers purpose, source of the ID, content format, and auth prerequisite. Nothing essential is missing, though it doesn't mention return values or error conditions, which are not required given the lack of an output schema.

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

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

Schema description coverage is only 33% (only dry_run has a description). The description compensates by explaining that issue_id comes from get_mod_bugs and that text supports BBCode. This adds meaning to two of the three parameters beyond the schema, though it doesn't explain dry_run beyond what the schema already provides.

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

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

The description clearly states the action (reply) and the resource (bug report), and specifies the source of issue_id from get_mod_bugs. It distinguishes from siblings like post_mod_bug (create) and delete_mod_bug by the word 'reply'.

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

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

It provides clear context for when to use this tool – replying to an existing bug report – and mentions the prerequisite of having an issue_id from get_mod_bugs. It also states the auth requirement. However, it does not explicitly name alternatives or state when not to use it, so it lacks exclusions.

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

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

Annotations already declare read-only, open-world, idempotent, non-destructive behavior. The description adds the key behavioral trait beyond that: the result set contains slug identifiers meant for downstream getters, and the search is scoped by collection name or game.

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

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

Two short sentences with no filler; the primary action and scoping are front-loaded, and the return contract is stated in the second sentence.

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 non-mutating search tool, it covers the main selection and invocation needs: what to search by and what comes back. It doesn't describe behavior when query/game are omitted or detail pagination, but the schema's defaults and bounds fill most of that gap.

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

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

With only 20% schema description coverage, the description helps by clarifying that 'query' means a collection name and by pairing it with game. It does not explain sort, count, or offset semantics, though their enums/defaults/bounds partially 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?

States a specific verb and resource ('Search collections') and the two supported dimensions ('by name / game'). It also differentiates from sibling getters by saying it returns slugs for get_collection and get_collection_comments, so an agent can tell search from retrieval.

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

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

The description gives clear workflow context: use this as the discovery step, then pass the returned slugs into get_collection or get_collection_comments. It doesn't explicitly list exclusions or alternatives, but the return-contract sentence makes the intended usage obvious.

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

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

Annotations already declare readOnlyHint, openWorldHint, idempotentHint, and destructiveHint=false. The description adds valuable behavior beyond those: no authentication is required, the results are game/modId pairs, and those pairs are directly consumable by other tools. It does not mention pagination or adult-content filtering, but the annotation coverage is strong and the added context is meaningful.

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, zero filler. The core action is front-loaded, and the second sentence delivers the two most important operational facts: no API key required and output suitability for other tools. Every word earns its place.

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

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

For a read-only search endpoint, the description covers the essentials: wildcard search, optional game filter, sorting, no auth, and reusable output. But with no output schema and several undocumented parameters, the agent is left guessing about response structure beyond the ID pair and how pagination/adult parameters behave. It is adequate but not fully complete for a tool with 8 parameters.

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 38%, so the description must compensate for the many undocumented parameters. It addresses query via 'by name (wildcard)' and game via 'optionally within one game', but count, offset, direction, author, and include_adult are not explained anywhere in the description. The description adds some meaning but leaves most parameters 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 states a specific verb and resource: search mods by name with wildcard support, optionally scoped to a game, with sorting. This clearly differentiates it from get_mod (single lookup) and list_mods (listing). However, it does not explicitly name a sibling tool or address the overlap with list_mods, so it stops just short of full 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 implies when to use the tool: when you need to discover mods by name and obtain IDs for subsequent calls. It explicitly says no API key is needed, which is a useful access condition. However, it gives no explicit guidance on when not to use it or which sibling alternative to prefer, such as list_mods for browsing all mods or get_mod for a known ID.

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

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

Annotations already declare readOnlyHint=false and destructiveHint=false, indicating a non-read-only, non-destructive mutation. The description adds no additional behavioral context (e.g., effects, authentication needs, side effects), but it does not contradict the annotations. Since annotations cover the safety profile, a 3 is appropriate for minimal added value.

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 zero filler. It is appropriately sized for a simple toggle operation, front-loading the essential 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?

The tool is simple with clear schema and annotations, but the description omits any note about prerequisites (e.g., authentication) or the effect of the operation. For a mutation tool, slightly more context would be helpful, though the minimalism is acceptable for a straightforward action.

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 67% with descriptions for game and mod_id, and the action parameter has an enum with a default. The description adds no extra meaning beyond what the schema provides, so it relies on the schema. Baseline of 3 is correct.

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 ('start or stop tracking') and the resource ('a mod'), which is specific and unambiguous. However, it does not distinguish this from siblings like get_tracked_mods or endorse_mod beyond the basic action, so it lacks explicit 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, nor any conditions or prerequisites. It simply states the action without context on choosing track vs untrack or when to call it.

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

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

Beyond the annotations (readOnlyHint=false, openWorldHint=true, idempotentHint=false), the description discloses meaningful behavioral traits: the operation publishes immediately, executes a multi-stage pipeline (multipart upload → finalise → wait → publish) that includes a wait, and has failure/recovery semantics via upload_id. This tells the agent the operation is long-lived and has external side effects that aren't retry-safe by re-uploading.

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?

Four compact sentences with zero filler. The core purpose is front-loaded in the first sentence, followed by prerequisite sourcing, failure recovery, and the optional changelog feature — each sentence earns its place and adds distinct operational value.

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

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

For a complex 15-parameter, multi-stage, failure-prone operation with no output schema, the description covers the essential workflow: purpose, pipeline, prerequisites, retry strategy, and optional feature gating. The main gap is the lack of an explicit return-value contract (the response presumably contains upload_id for the retry path, but this is only implied, not stated), plus a few undocumented boolean params remain unexplained.

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 67% schema coverage, the schema covers most parameters, and the description adds genuine value for the critical ones: mod_file_id's source ('from get_upload_targets'), upload_id's role in the retry path, and mod_uid's purpose ('needed for changelog'). It doesn't fully compensate for the ~5 undocumented parameters (show_requirements_pop_up, allow_mod_manager_download, primary_mod_manager_download, etc.), so it's a 4 rather than a 5.

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: 'Upload a local archive as a NEW VERSION of an existing mod file and publish it immediately'. It clearly distinguishes itself from siblings like upload_mod_image (uploading an image, not a file version) and add_changelog (text-only changelog), and even previews the internal pipeline to remove 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 gives clear usage context: it names the prerequisite source ('Get mod_file_id from get_upload_targets'), explains the retry flow when publishing fails ('retry with upload_id to skip re-uploading'), and states the changelog requirement ('needs mod_uid'). However, it doesn't explicitly name alternatives or state when NOT to use it versus sibling operations, so it falls short of a 5.

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

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

Beyond the annotations (readOnlyHint=false, destructiveHint=false), it reveals the internal sequence (safety hash check, upload, media cache refresh) and the authentication requirement. This gives the agent useful expectations for side effects and failure modes.

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 main action is front-loaded in the first words, constraints are compact, and the internal workflow is packed into a colon-delimited list. Every segment earns its place; there is no filler.

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

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

For a moderately complex mutation with no output schema, it conveys the essential context: target, file constraints, internal steps, and auth. It doesn't describe the return value or success/error behavior, and show_in_gallery is left unexplained, but an agent can still invoke the tool correctly.

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

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

The schema already documents game, dry_run, and file_path, with 60% coverage. The description adds key constraints not in the schema: JPG/PNG/GIF and 8 MB limit for file_path, and 'YOUR mod' clarifies that mod_id must be owned by the authenticated author. show_in_gallery is still not explained.

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 'Upload' with the target resource 'an image ... to YOUR mod's gallery', and names the supported formats and size limit. This clearly differentiates it from siblings like delete_mod_image, upload_file_version, and add_mod_video.

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

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

It gives clear usage context: this is for adding an image to the caller's own mod gallery, mimicking the mod editor, and only with the author's web session. It doesn't explicitly contrast with alternatives such as delete_mod_image or add_mod_video, so it misses the strongest when-to-use guidance.

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

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

Annotations already declare readOnlyHint=true, idempotentHint=true, and destructiveHint=false, so the safety profile is fully covered. The description adds useful context about what the validation returns (account name, premium/supporter, rate limit), which goes beyond the annotations. However, it doesn't disclose details like whether the key is read from an environment variable or how errors are reported.

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

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

One sentence, front-loaded with the primary action ('Validate NEXUS_API_KEY'), and every clause adds value: what is validated, what account info is shown, and what rate-limit info is included. 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, read-only validation tool, the description is nearly complete. It covers the purpose, the implicit input (NEXUS_API_KEY), and the output (account name, premium/supporter, rate limit). It doesn't mention error behavior or how the key is provided, but those are minor gaps given the tool's simplicity and the annotations covering safety.

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 is empty and there is nothing to document. The description explains what the tool does with the implicit NEXUS_API_KEY, which is the only relevant input. With 0 params, a baseline of 4 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 states a specific verb ('Validate') and resource ('NEXUS_API_KEY'), and clearly distinguishes this from sibling tools like get_user or web_login by focusing on API key validation and account status. It also specifies what the tool shows: account name, premium/supporter status, and remaining rate limit.

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 the tool to use when you need to check if an API key is valid and see account/rate-limit info. It doesn't explicitly name alternatives or exclusions, but the context is clear enough given the sibling list (e.g., get_user is for user profiles, web_login for browser sessions).

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

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

Annotations indicate non-read-only, open-world, idempotent, non-destructive behavior mustard, and the description adds meaningful context: cookie extraction, visible sign-in fallback, automatic session capture, and persistence across runs. This goes beyond what the annotations alone provide and matches them without contradiction.

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

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

The description is two compact sentences that front-load the purpose, then explain the mechanism and the required post-sign-in action. Every sentence earns its place without redundancy or fluff.

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

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

For a zero-parameter login helper, the description covers the workflow, fallback behavior, persistence, and next-step instruction. It does not explicitly state what the session object looks like or how to pass it, but that is not critical given the 'captured automatically' phrasing and the tool's integration-oriented purpose.

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

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

There are zero parameters and schema description coverage is 100%, so there is no parameter semantic gap for the description to fill. The baseline of 4 applies because no parameter documentation 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 clearly identifies the operation as 'Get a nexusmods.com session' and explains the method: extract cookies from installed browsers, otherwise open a visible sign-in window. This distinguishes it from session-related siblings like web_status and web_set_cookies by focusing on obtaining a session rather than checking or setting 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 description implies when to use it: before acting on a nexusmods.com session, with the instruction to re-run the action after signing in. It does not explicitly name alternatives or exclusions, but the context is clear enough for an agent to select it for session bootstrap.

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

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

Annotations already signal idempotency and non-destructiveness, and the description adds the cookie-string format and browser provenance. It does not state whether existing cookies are overwritten or how this affects the session, but the annotations cover the main safety 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?

One concise sentence that front-loads the action and immediately provides the required cookie format. No filler or redundancy.

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

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

For a single-parameter setter with idempotence already annotated, the description covers action, resource, parameter format, and provenance. It omits response/persistence details, but those are minor at this complexity level.

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 only provides a minLength string, so the description supplies the essential grammar: 'name1=value1; name2=value2'. This fully compensates for 0% schema description coverage and removes ambiguity about input 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?

States a concrete action ('set') on a specific resource ('nexusmods.com cookies') and includes the exact cookie header format. It is clearly distinct from auth-related siblings like web_login or web_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 implies use in a manual flow where the caller provides cookies from a logged-in browser, but it never explicitly says when to prefer this over web_login or when not to use it. No alternatives or exclusions are named.

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

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

Annotations already declare readOnlyHint, idempotentHint, openWorldHint, and destructiveHint=false, so the safety profile is covered. The description adds the 'needed only for WRITE tools' dependency but does not disclose the return shape or what a logged-in vs. logged-out result looks like. This is acceptable but not rich.

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

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

The description is one short sentence that front-loads the action and immediately provides the key usage condition. 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 simple parameterless status check, the description captures the purpose and the main precondition. There is no output schema, but 'check whether' reasonably implies a boolean result; slightly more detail on the response would make it fully complete.

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

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

The tool has zero parameters and the schema coverage is 100%, so there is no parameter documentation burden on the description. Baseline 4 for parameterless tools 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 states a specific action — checking whether the browser session is logged in to nexusmods.com — and distinguishes it from the many sibling tools by tying it explicitly to web-tier WRITE tools. This is a clear verb+resource statement, not a tautology.

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

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

It gives explicit usage context: 'needed only for web-tier WRITE tools.' This tells the agent when to invoke it. It does not name alternatives like web_login or web_set_cookies, but the conditionality is clear enough to route an agent appropriately.

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