WindowsForum MCP Server

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

Annotations already mark the tool as read-only and non-destructive. The description adds useful behavioral context beyond that by defining exactly what 'health' means: status histogram, missing supplements, drifted approved cards, and generation run summary. This helps the agent predict what the tool reports without contradicting 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 entire description is one dense sentence that front-loads the core purpose and then lists the key metrics in a dash-separated sequence. Every phrase contributes meaning, and there is no filler or repetition of the tool name or 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 parameterless read-only tool with an output schema, the description covers all essential context: what corpus it applies to, the aggregate nature of the data, and the specific metrics an agent can expect. No critical usage or behavior details are 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 tool has zero parameters, so the baseline is 4. There is no parameter detail needed, and the description correctly focuses on what the tool returns rather than input 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 ('Get'), a clear resource ('Key-Facts supplement corpus'), and enumerates four concrete outputs (status histogram, missing supplements, drifted cards, generation run summary). It distinguishes the tool as an aggregate health overview from sibling tools like list_drifted, but it does not explicitly name a sibling or state what this tool 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 this is the right choice for high-level corpus health summaries rather than item-level listing or search, but it never explicitly states when to use this tool versus siblings such as supplement_status or list_drifted. An agent must infer the boundary from the word 'aggregate' rather than being told.

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

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

Annotations already declare readOnlyHint=true and destructiveHint=false, so the safety profile is covered. The description adds useful behavioral context by stating that it returns the full text plus title, URL, and metadata, which goes beyond the annotation-only signal. No contradictions exist.

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

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

The description is short and front-loaded with the core action and purpose. It repeats 'detailed analysis and citation' twice, which is mildly redundant, but the text remains efficient and well organized.

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 fetch tool with an output schema, the description is sufficiently complete: it states what is retrieved, when to use it, and what the output includes. There are no major gaps that would prevent an agent from invoking 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%, and the id parameter is already well documented with accepted formats and lookup order. The description repeats the thread/post concepts but adds no new meaning beyond what the schema provides, so the baseline 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 identifies the action as retrieving the complete content of a WindowsForum document (thread or post) by ID. It gives a specific verb and resource, and the 'use after search to read the full discussion' phrasing helps position it against related tools, though it does not explicitly contrast it with get_thread or get_post.

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 says to use this after search to expand a result into its whole document, giving clear context for when it is appropriate. It does not state exclusion criteria or name alternatives like get_post/get_thread, but the 'use after search' guidance is strong 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 declare readOnlyHint=true and destructiveHint=false. Description adds specific return fields (title, description, counts), slightly enhancing transparency without contradicting 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?

Single efficient sentence with primary action front-loaded. No filler; every word serves 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?

Given a simple tool with one parameter, rich annotations, and output schema present, the description sufficiently explains what the tool returns and suggests companion tools for broader use.

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

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

Schema covers 100% of parameter documentation with clear description. Description's 'by node id' adds no new meaning. Baseline score of 3 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?

Description specifies exact verb 'Get', resource 'WindowsForum forum section's details', and lists returned data (title, description, counts). Differentiates from siblings like get_forum_updates by noting it's for static details.

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?

Description advises pairing with list_threads or get_forum_updates for activity, providing usage context. Lacks explicit when-not-to-use or alternatives like get_forum_statistics but still helpful.

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

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

Annotations already declare readOnlyHint=true and destructiveHint=false, so the safety profile is covered. The description adds that it returns a dictionary of forum statistics, but does not disclose any further behavioral traits such as freshness, latency, or limits. 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 main sentence is front-loaded and efficient. The 'Returns: Dictionary with various forum statistics' line adds little because the output schema exists and 'various' is vague, but the description remains compact and clear overall.

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

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

Given zero parameters, existing annotations, and an output schema, the description fully covers what the tool does and when to use it. No critical information is missing for an agent 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?

The tool has zero parameters, so the baseline is 4. There is no parameter documentation burden for the description to carry, and the empty schema confirms no inputs are 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 begins with a specific verb and resource: 'Get sitewide WindowsForum statistics' and enumerates exactly what is included (total threads, posts, members; threads and posts created today). This clearly distinguishes it from sibling tools such as get_forum or corpus_stats.

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 states when to use the tool: 'use for questions about the community's size and activity.' It does not name alternatives or exclusions, but the use case is clear and the tool has no parameters, so routing is straightforward.

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 read-only, non-destructive. Description adds value by clarifying time window (last N hours) and scope (across community). No contradictions.

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

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

Single sentence with semicolon is concise and front-loaded. Every word adds value: verb, resource, time scope, and use case. No waste.

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 single parameter, high schema coverage, and presence of output schema, the description fully covers purpose, usage, and scope. Sibling list is large, but the description clearly differentiates.

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% and already describes the 'hours' parameter with default and meaning. Description restates the default but adds no additional constraint info. 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?

Description states verb 'Summarize' and resource 'recent WindowsForum activity', explicitly calling out 'new threads and posts' and targeting 'what's new' questions. Distinguishes from siblings like get_forum_statistics and get_thread.

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

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

Clearly specifies use case ('what's new' questions) with a default time window. No explicit when-not-to-use, but the guidance is sufficient for a simple 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 mark readOnlyHint and destructiveHint, so the description adds value by detailing the source (support.microsoft.com) and content returned (title, summary, affected builds, known issues, resolution steps). 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?

The description is two paragraphs, front-loading the core function and then providing usage guidance. Some redundancy exists (title/summary repeated), but it's concise overall.

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

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

For a simple tool with one parameter, output schema, and clear annotations, the description is complete enough. It covers the KB number format, content returned, and usage scenario. Minor omission: no mention of potential missing articles or rate limits, but not critical.

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 a description for kb_id. The description adds examples like 'KB5063878' and clarifies that the 'KB' prefix is optional, enhancing the schema's information.

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

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

The description clearly states the tool retrieves a Microsoft KB article by KB number, specifying it returns title, summary, affected builds, and later mentions known issues and resolution steps. It distinguishes from siblings like search_kb by noting it is for specific KB numbers.

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 says 'Use this tool when a user asks about a specific KB number,' providing clear usage context. While it does not name alternative tools, the sibling list includes search_kb, implying its contrasting use case.

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

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

Annotations already declare readOnlyHint=true and destructiveHint=false, so the main safety profile is covered. The description adds meaningful behavioral context by specifying that only confirmed, non-banned accounts are listed, matching the forum's own 'New members' list. This clarifies the filtering behavior 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 compact and front-loaded with the main purpose; the second sentence adds important filtering context. Every sentence earns its place with no filler or redundancy.

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

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

Given the single optional parameter, complete schema coverage, read-only annotations, and the existence of an output schema, the description provides all necessary context: what the tool returns, who is included/excluded, and when to use it. Nothing critical 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 only parameter, 'limit', is fully documented in the schema with a clear description and default value (schema coverage 100%). The description does not add parameter-level detail, but none is needed since the schema is complete. 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 states a specific verb ('List'), a precise resource ('newest WindowsForum member registrations'), and the intended use cases ('community-growth questions' or 'identify recent joiners'). This clearly differentiates it from sibling tools like get_online_users, get_user, and search_users.

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 to use the tool ('community-growth questions' or 'identify recent joiners'). It does not explicitly mention exclusions or alternatives, but the stated purpose is sufficient for an agent to select it appropriately among the 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?

Beyond the annotations' read-only and non-destructive hints, the description discloses the activity window (last 15 minutes) and the privacy-relevant detail that only members who show their online status are named. This is useful behavioral context that structured annotations do not provide.

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 definition is three short sentences, front-loads the primary purpose, and adds a Returns section without redundant elaboration. Every sentence contributes new information.

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

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

For a zero-parameter, read-only tool with an output schema and clear annotations, the description fully covers what the tool returns and the meaning of the data. There is no missing operational detail an agent would need 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?

The tool has zero parameters, so there is no parameter documentation burden; the baseline of 4 applies. The description is entirely sufficient for calling the tool without further parameter guidance.

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

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

The description states a specific resource (current online presence on WindowsForum) and the exact metrics returned (member/guest/robot counts plus visible member names). It clearly differentiates this from siblings like get_latest_registered_users and get_forum_statistics by emphasizing 'right now' and the 15-minute activity window.

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 opening 'See who is on WindowsForum right now' gives a clear use case: checking current online activity. The 15-minute active window sets expectations, and while it does not explicitly name alternative tools, no prerequisites or conflicting use cases are left ambiguous.

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

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

Annotations already declare readOnlyHint=true and destructiveHint=false, so the description does not need to repeat safety info. It adds value by detailing return fields (text, author, thread context, URL), providing behavioral context 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?

The description is a single efficient sentence covering action, resource, identifier, return data, and usage hint, with no wasted words.

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

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

With only one parameter and an output schema present, the description adequately covers what the tool does, how to use it, and when to use it, leaving no significant gaps.

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

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

Schema coverage is 100%, and the schema already describes post_id as 'The post ID to retrieve.' The description only restates 'by post id' without adding format or constraints, so 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 verb (Get), resource (single post), and identifier (by post id). It lists return fields (text, author, thread context, URL), distinguishing it from sibling tools like get_thread_posts or get_thread.

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

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

The description explicitly states when to use: 'use when you have a specific post reference to verify or quote.' It implies alternatives if no specific reference exists, but does not explicitly list when not to use.

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 annotations (readOnlyHint=true), the description details the returned fields and emphasizes metadata-only nature, adding behavioral context.

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

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

Single concise sentence with clear function, output specification, and usage guidance. 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?

Fully adequate for a simple tool with annotations, output schema, and clear sibling differentiation. No 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 coverage is 100% with a clear description for thread_id. The tool description adds no further parameter details, but the single integer ID is straightforward, so 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 it retrieves thread metadata by ID, listing specific fields (title, author, counts, dates, URL). It distinguishes from siblings like fetch and get_thread_posts for content 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?

Explicitly directs agents to use fetch or get_thread_posts for content, providing clear context for when to use this tool vs alternatives.

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

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

Annotations already mark it as read-only and non-destructive. The description adds value by noting posts are returned in order and include replies and accepted solutions.

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

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

Single sentence that efficiently conveys purpose, use case, and key behavior with no unnecessary 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?

With an output schema present and only two straightforward parameters, the description covers all necessary context for correct invocation.

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

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

Schema coverage is 100% with descriptions for both parameters. The description adds no new parameter semantics beyond what the schema 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 tool reads every post in a thread by ID, including replies and accepted solutions, distinguishing it from single-post or search tools.

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

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

The description indicates it should be used after finding a thread via search, but does not explicitly list when not to use or contrast with get_post for a single post.

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

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

Annotations already declare readOnlyHint=true and destructiveHint=false. The description adds that the tool returns the current timestamp in ISO format, which is consistent and informative.

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, instantly gives the purpose and usage context, with no unnecessary 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?

Despite having an output schema, the description explicitly states the return format (ISO timestamp), which fully informs the agent. The tool is simple and the description covers all needed 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?

There are no parameters, so the baseline is 4. The description does not need to add parameter information since the schema is fully covered.

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 'Get' and resource 'current server date and time', and distinguishes this tool from siblings by specifying it provides a timestamp to anchor queries, which is unique among the listed 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?

The description explicitly says 'use to anchor time-sensitive queries', providing clear context for when to use this tool, though it does not mention when not to use or 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 and destructiveHint=false. The description adds meaningful behavioral context beyond annotations: what a signed-out visitor would see, profile-limited members getting username-only results, and last seen being omitted when online status is hidden.

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

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

The description is compact, front-loaded with the core purpose, and each sentence earns its place. It avoids filler while still covering the essential behavior.

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

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

For a single-parameter read-only tool with an output schema, the description is complete. It covers the lookup key, the returned profile fields, and the important privacy-driven output variations, leaving nothing an agent needs 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 coverage is 100%, with the identifier parameter described as 'Username or user ID'. The description repeats the same meaning without adding extra format, case-sensitivity, or ambiguity guidance, so it stays at the baseline for fully 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?

States a specific verb ('Look up'), a clear resource ('a WindowsForum member's public profile'), and exact lookup keys ('by username or user id'). The listed returned fields and the exact-identifier semantics make it easy to distinguish from sibling search/list tools such as search_users or get_latest_registered_users.

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

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

The description implies the intended use: retrieve a public member profile when you have an exact username or user id. It does not explicitly state when not to use it or point to alternatives like search_users, though the visibility caveat provides some context about limitations.

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

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

Annotations already declare readOnlyHint=true and destructiveHint=false, indicating safe read-only behavior. The description adds context about the time window (last N days), default value of 7, and the curated nature of the news threads, which goes beyond annotations to set expectations on the scope and nature of results.

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 efficiently conveys the source, time range, default, and content type. No redundant words, well-structured.

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

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

Given the tool's simplicity (single parameter, with output schema present), the description is complete. It sets clear expectations for what the tool returns and the parameter meaning. The output schema likely handles return structure.

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 a clear description for the single parameter 'days'. The tool description repeats the default value, adding no new semantic information. Baseline score of 3 is appropriate as schema already covers parameter meaning.

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

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

The description clearly states it retrieves recent Windows news coverage from WindowsForum, specifying the content type (curated news threads on updates, security patches, and Microsoft announcements). This specific verb+resource combination distinguishes it from sibling tools which handle general forum content or search.

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

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

The description implies this tool should be used for Windows news, but it does not explicitly state when not to use it or mention alternatives among siblings. The context of sibling tools provides implicit guidance, but explicit usage guidelines are missing.

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 tool as readOnly and non-destructive. The description adds meaningful behavioral context by explaining the drift mechanism and the 'dark card' state, which is not derivable from the annotations or schema. It does not describe pagination or sorting behavior, but the output schema likely covers return structure.

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 carry the core purpose, the triggering condition, and the operational context without any filler. The key differentiator is front-loaded, making it easy for an agent to scan and select correctly.

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 operation with one optional parameter, a rich output schema, and full annotation coverage, the description provides everything needed. It explains what the tool returns, why these threads matter, and how they are identified. No critical gap remains.

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

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

Schema description coverage is 100%, and the only parameter is `limit` with a clear default and range. The description adds no extra parameter semantics, but it doesn't need to because the schema fully documents the single optional parameter. 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 states a specific verb and resource: list article threads with a dark Key-Facts card caused by content-hash drift after an opening-post edit. This clearly distinguishes it from sibling tools like list_threads and search_threads, which do not target this specific drifted state.

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 relevant: when identifying threads whose approved Key-Facts card is dark because the opening post changed after approval. It also notes these are exactly what the hourly fill driver repairs next, which implies operational selection. It stops short of explicitly naming alternatives or stating when not to use it.

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

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

Annotations already declare readOnlyHint=true and destructiveHint=false, establishing safety. The description adds behavioral context: it returns items in newest-first order, supports multiple content types (threads, news, tutorials), and implies no search filtering. It does not describe pagination or result limits beyond the schema parameters, but the openWorldHint=false adds context that results are from a closed set. Overall, adds useful context 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?

Two sentences with zero waste. The primary purpose and usage condition are front-loaded, followed by a directive on how to render results. Every phrase 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 read-only list tool with 3 optional parameters fully documented in the schema, an output schema present, and clear usage guidance, the description is complete. It covers when to use, what it returns (newest items), how to display results, and the absence of search. An agent can call it correctly without further info.

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 parameters are fully documented in the schema. The description adds value by clarifying the 'section' parameter's meaning ('tutorials' for latest tutorials, etc.) and reinforcing that no search query is involved. It goes slightly beyond the schema by implying default behavior and common use cases, but doesn't introduce new details about limit/offset formatting.

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

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

The description states a clear verb ('List'), resource ('newest WindowsForum threads, news articles or tutorials'), and ordering ('newest first'), distinguishing it from search tools. However, it doesn't explicitly name a sibling or contrast with similar list tools (e.g., get_forum_updates), so differentiation is slightly less precise than ideal.

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

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

Provides explicit usage guidance: 'use when the user asks for the latest, newest or most recent tutorials, news or threads' and states it's for no search query, distinguishing from search tools. It also instructs to pass item `id` to render_search_results for display, giving clear action 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?

The annotations already declare readOnlyHint=true and destructiveHint=false, which covers the safety profile. The description adds the output contents (like 'who is online now' and 'latest threads') but does not disclose any further behavioral traits such as data freshness, aggregation behavior, or rendering format.

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: the first defines the tool's purpose and output, the second gives usage guidance. No redundancy or filler, and the main action 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 zero-parameter tool with no output schema, the description adequately lists what is displayed and when to use it. It does not describe the card's visual structure or refresh behavior, but those are not essential for correct invocation 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 tool has zero parameters and the schema is empty (100% coverage). The description correctly does not need to explain parameters, matching the baseline of 4 for parameterless tools.

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

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

The description clearly states the tool renders a community overview card and lists its contents (threads, posts, members, online users, latest threads). It is specific about the resource, but it does not explicitly name sibling tools or contrast with options like get_forum_statistics or get_online_users, 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 tool gives clear usage context: 'Use for questions about the community's size or current activity.' However, it does not state when not to use it or point to alternatives, so it lacks explicit exclusions.

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

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

Annotations already declare readOnlyHint=true, openWorldHint=true, and destructiveHint=false, covering the safety profile. The description adds useful behavioral context by specifying that the article is rendered as a card with only title, highlights, and link, rather than full article content.

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 earn their place: the first explains what the tool does and its output format, the second states the invocation condition. No redundant or vague wording.

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

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

The tool has a single parameter, full schema coverage, and annotations covering the read-only nature. The description supplies the expected card presentation. For a low-complexity rendering tool, nothing essential is missing.

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

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

Schema coverage is 100% and the single kb_id parameter is fully documented with format examples. The description's mention of 'a specific KB article' aligns with the parameter but adds no new semantic detail, so the baseline 3 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 a specific verb ('Show') and resource ('official Microsoft Knowledge Base article'), and describes the output form: 'a card with its title, highlights, and link to support.microsoft.com.' This differentiates it from siblings like get_kb_article, which likely fetches raw article data rather than rendering a user-facing card.

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 includes a clear usage trigger: 'Use when the user asks to see a specific KB article.' It does not explicitly mention exclusions or alternatives such as get_kb_article or search_kb, so it falls just short of a 5.

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

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

Annotations already declare readOnlyHint=true and destructiveHint=false, so the safety profile is covered. The description adds meaningful behavioral detail: it renders a card grouped by section, displays title, snippet, author, date, and link, and preserves the order of passed ids. This is beyond the annotations and helps the agent understand the output 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?

Three sentences with no fluff. Purpose is front-loaded, workflow follows logically, and the display details are concise. 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 rendering tool with read-only annotations and no output schema, the description covers the main workflow, display contents, and ordering. It could mention what happens with invalid ids or explicitly state it does not search, but the 'call search first' instruction covers that. Overall complete for the agent's needs.

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% and both parameters have clear descriptions. The description reinforces the ids parameter as document ids to display and mentions order preservation, but adds little beyond the schema. It also references the query as the card heading, which is already in the schema. Baseline of 3 is appropriate given high 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?

Description states a specific verb ('Show') and resource (threads, news, tutorials, posts as a result card), and implicitly distinguishes from sibling render tools like render_thread and render_kb_article by focusing on a grouped result card. It clearly conveys what the tool does.

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

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

Explicitly prescribes the workflow: call search or list_threads first, select relevant results, preserve order, then pass ids. This gives clear when-to-use guidance and implies it is for displaying multiple search results, not for individual rendering. It names the prerequisite tools directly.

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

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

Annotations already declare readOnlyHint=true and destructiveHint=false, so the description is consistent. It adds context beyond those annotations by specifying the presentation behavior ('readable card'), which is useful for an agent to understand the output format. It does not contradict 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 two concise sentences with no filler. The main purpose is front-loaded, and the usage guidance follows immediately. 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-only tool with a single well-documented parameter and no output schema, the description fully covers what the agent needs to know to invoke it correctly. It includes when to use it and what it does, leaving no critical gaps.

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

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

The schema provides a complete description for thread_id (type, example), achieving 100% coverage. The tool description adds no additional parameter guidance beyond what the schema already includes, so the baseline 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 shows a WindowsForum thread as a readable card with opening post and replies, which is a specific verb+resource+format. It distinguishes from sibling tools like get_thread by emphasizing the presentation aspect ('readable card') rather than raw data 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 explicitly instructs to use this tool after search or fetch when the user wants to see or open a specific discussion. It provides clear context for when to invoke it, though it does not explicitly mention alternatives or 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 declare readOnlyHint=true and destructiveHint=false, so the safety profile is covered. The description adds behavioral context: combined keyword and semantic ranking, the 'best first call' role, default section behavior, and the fact that it returns 'basic information' only. It also discloses the sort behavior for queries without a topic. No contradiction with annotations.

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

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

The description is concise and front-loaded with purpose, then usage, then output/next-step guidance. Every sentence earns its place, though it could be tightened slightly by removing the final sentence about fetch, which is already implied by 'basic information.'

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

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

An output schema exists, and the description covers the return type ('a list of search results with basic information') and points to fetch for full content. It also mentions the render step. For a search tool with a clear parameter set and safety annotations, this is complete enough. The only minor gap is no explicit mention of pagination, but the limit parameter covers 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 each parameter is already documented. The description adds little beyond the schema: it reinforces the 'combined keyword and semantic ranking' aspect (relevant to the source parameter) and the natural-language-query hint, but these are already in the schema descriptions. 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 states a specific verb ('Search'), a clear resource ('all WindowsForum content'), and the scope (community threads, Windows news, tutorials). It explicitly positions itself as 'the best first call for any question or topic,' which differentiates it from the many sibling search tools without requiring the agent to compare 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?

Provides explicit guidance: keep section 'all' unless the user asks for one content type, and set sort='newest' for latest items. It also chains to render_search_results and fetch, telling the agent the next steps. It stops short of naming specific alternative tools or saying when NOT to use it, but the 'best first call' phrasing implies it is the default.

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

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

Annotations already declare readOnlyHint=true and destructiveHint=false. The description adds useful behavioral context: the search is relevance-ranked, full-text, and uses explicit offset pagination. It goes beyond the annotations but does not address aspects like result limits or response shape, though an output schema 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 short and front-loaded with the core purpose. However, the phrase 'use to page through a large result set' appears twice in slightly different forms, creating minor redundancy. Still, every sentence earns its place and it remains efficient.

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

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

Given the output schema and complete parameter descriptions, the tool is adequately specified. The description clarifies when to choose it over the main `search` tool and communicates the pagination model. It does not explain distinctions from other search variants like `search_mysql` or `search_semantic`, but those are not required for basic correct invocation.

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

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

Schema description coverage is 100%, so the parameters are already fully documented. The description adds no syntax details beyond what the schema provides, but the pagination and relevance-ranking hints align with the `from_`/`size` and `query` parameters. 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 states a specific verb and resource: 'Relevance-ranked full-text thread search with explicit offset pagination'. It clearly distinguishes this tool from the main `search` tool by emphasizing pagination and large result sets, which is reinforced by the title 'Paginated thread search'.

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 explicitly says when to use this tool: 'use to page through a large result set beyond what the main search tool returns'. It names the alternative `search` tool and gives a concrete condition, making the routing decision unambiguous.

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

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

Annotations declare readOnlyHint and destructiveHint false, so the safety profile is already covered. The description adds value beyond annotations by stating result ordering is newest first and enumerating returned fields (kb_id, title, url, release_date, applies_to), though it does not disclose potential external-source behavior or pagination limits 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 short and front-loaded with the main purpose and usage condition. A small redundancy exists between the first paragraph's summary of returned data and the later 'Returns' section, but the later section adds exact field names, so it is not wasted.

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

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

For a simple two-parameter search tool, the description effectively covers query semantics, return structure, sorting behavior, and a sibling alternative. It is complete enough for an agent to call correctly, though it could slightly improve by explicitly linking 'have a KB number' to get_kb_article.

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 already documents query and limit, with examples and defaults, so the baseline is 3. The description adds semantic meaning by clarifying that queries may target topic, keyword, build, or KB number, going slightly beyond the schema examples. Limit is not expanded in the description, but the schema covers it 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 specific verb and resource: searching official Microsoft Knowledge Base articles for Windows 10, Windows 11, and Windows Server updates. It also distinguishes itself from siblings by naming get_kb_article for fetching full article content, making the tool's role clear.

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 identifies when to use the tool: Windows update, patch, and known-issue lookups when a KB number is lacking, and it points to get_kb_article as the alternative for fetching full content. It does not explicitly enumerate when not to use other search siblings, hence 4 rather than 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 provide readOnlyHint=true and destructiveHint=false, lowering the burden. The description adds useful behavioral context: matching is exact substring, and results are ordered by view count. It does not mention pagination or rate limits, but for a read-only search tool with an output schema this is sufficient additional disclosure.

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

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

The first sentence conveys the full substance: exact substring lookup, target fields, ordering, and the contrast with relevance-ranked search. The second sentence repeats the same 'literal vs relevance-ranked' contrast and the relationship to `search`, adding no new information. This redundancy means not 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?

Given the 100% schema coverage, safe read-only annotations, and presence of an output schema, the description provides adequate context: what is searched, matching semantics, ordering, and when to prefer this tool over `search`. Nothing critical for correctly invoking the tool appears to be 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?

Schema description coverage is 100%, and the schema already provides rich, self-explanatory descriptions for `query`, `limit`, and `section`. The tool description's mention of exact substring matches `query` and adds no parameter-level meaning beyond what the schema already documents. Baseline 3 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 a specific operation ('Exact substring lookup over thread titles and author usernames'), names the ordering ('ordered by view count'), and contrasts itself with relevance-ranked full-text search. This makes its purpose immediately clear and distinguishes it from the sibling `search` tool without needing to inspect 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 explicitly says to use this tool for literal title/author matching rather than relevance-ranked full-text search and names `search` as the complementary alternative. It is clear about the primary decision, though it does not distinguish from other search siblings like `search_threads` or `search_users`. The core usage guidance is present.

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 tool as read-only and non-destructive, covering the safety profile. The description adds meaningful behavioral context by specifying the search scope (individual post content, not titles) and the intended purpose. It does not disclose pagination or matching semantics, but the output schema covers return structure, so the additional context is sufficient.

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

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

One sentence of about 29 words, front-loaded with the action ('Search individual WindowsForum posts') followed by a pragmatic use case. No filler, no repetition, and 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?

With a complete input schema, an output schema, and read-only annotations, the description only needs to convey purpose and selection context, which it does. It distinguishes from thread-title search but not from the other search siblings (search_elastic, search_mysql, search_semantic), leaving some ambiguity among the wider tool set.

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

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

Schema description coverage is 100%, with the section parameter's enum values and usage guidance already fully explained in the schema. The description's phrase 'keyword or phrase' loosely maps to the query parameter but adds no new parameter-level information. Baseline 3 applies because the schema does the heavy lifting.

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 ('Search'), a specific resource ('individual WindowsForum posts'), and explicitly contrasts with 'not just thread titles', distinguishing it from sibling search_threads. It also names the use case (answers, error messages, fixes buried in long threads), making the tool's purpose unambiguous.

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

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

It gives an explicit when-to-use cue: 'use to find specific answers, error messages, or fixes buried inside long threads.' The phrase 'not just thread titles' implies a contrast with thread-title search, but it never names an alternative tool or states when not to use it, so it falls short of a full 5.

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

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

Annotations already declare readOnlyHint=true and destructiveHint=false, so the safety profile is covered. The description adds the kNN vector similarity mechanism and the fact that results may not share exact keywords, which is useful behavioral context. However, it doesn't disclose details like result ordering, pagination, or potential latency, which would be valuable for a semantic search 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 concise and front-loaded with the core purpose. The first sentence states what the tool does, and the second paragraph explains the mechanism. It's slightly redundant with the title and the schema's section description, but overall it's efficient and well-structured.

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

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

Given the output schema exists and annotations cover the safety profile, the description is fairly complete. It explains the semantic search mechanism, when to use it, and the section parameter's behavior. It could mention result ordering or how it differs from search_elastic, but for a read-only search tool with a rich schema, this is adequate.

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

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

Schema description coverage is 100%, so the schema already documents all three parameters. The description adds the conceptual framing of 'query' as a natural language query and the section parameter's guidance about keeping 'all' for questions, which is helpful. But the description doesn't add significant meaning beyond what the schema already provides, so 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 tool's purpose: finding WindowsForum discussions by meaning rather than exact words, using embedding-based semantic search. It explicitly distinguishes itself from keyword-based search by emphasizing natural-language questions and paraphrased topics, which differentiates it from sibling tools like search, search_elastic, and search_mysql.

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 this tool: best for natural language questions and conceptual searches. It doesn't explicitly name alternatives or state when not to use it, but the contrast with exact-keyword search is implied. The section parameter description adds practical guidance on when to use specific values, which helps an agent decide.

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 readOnlyHint=true and destructiveHint=false, so the safety profile is covered. The description adds only the structured sort/pagination behavior, which is useful but does not go beyond what one would expect from a read-only search 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?

A single front-loaded sentence states the verb, resource, key options, and usage trigger with no filler. It earns its place and 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 read-only search tool with an output schema and fully described parameters, the description is largely complete. It could strengthen sibling differentiation among the many search_* tools, but the core selection and usage information is present.

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%, and the schema descriptions already define sortby values, order, size, from_, and section. The description's mention of sorting and pagination maps to those parameters without adding new parameter-level meaning, so the baseline of 3 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 names a specific verb ('Search'), a specific resource (WindowsForum threads), and its distinguishing capability (sorting by relevance, date, replies, or views with pagination). This differentiates it clearly from siblings like search_posts or the generic search tools.

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

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

It explicitly states when to use this tool: 'use when result ordering or paging matters.' It does not name alternatives or state when not to use it, but the positive trigger is clear and actionable.

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

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

Annotations already declare readOnlyHint=true and destructiveHint=false, so description adds limited behavioral context (e.g., matches usernames). Does not disclose query behavior like partial matching or pagination, but not contradictory.

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

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

Single sentence that efficiently conveys purpose and usage. No redundant information.

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

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

Given the simplicity of the tool (2 params, 1 required) and existence of an output schema, the description is largely sufficient. Could mention limit default behavior, but 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 coverage is 100% with descriptions for both parameters. Description does not add additional meaning beyond what the schema provides, so 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?

Clearly states verb 'Find' and resource 'members whose usernames match a query'. Differentiates from sibling tools like get_user and other search tools by specifying it's for locating a member before fetching full profile.

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 states the workflow: use this to locate a member before calling get_user. However, it does not mention alternatives like search_posts or when not to use this tool.

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

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

Annotations already declare readOnlyHint=true, openWorldHint=false, and destructiveHint=false, so the safety profile is covered. The description adds meaningful behavioral context beyond annotations by detailing the lifecycle values, the notion of a live 'current' revision, and the 'dark' state caused by edits after approval. It does not contradict 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?

Two sentences with no filler. The first sentence front-loads what the tool returns, and the second gives a concrete diagnostic use case. Every clause adds useful information.

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

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

The tool has a single required parameter, safe read-only annotations, and an output schema that can carry the return-structure details. The description provides the diagnostic scenario, explains the meaning of 'dark', and covers all state categories an agent needs to decide whether to call this tool. Nothing essential is missing.

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

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

Schema description coverage is 100% and thread_id is adequately documented as 'XenForo thread ID'. The description reinforces that it targets 'one article thread' but adds no essential parameter semantics beyond the schema, so the baseline 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 states a specific verb ('Get'), a specific resource ('Key-Facts supplement state for one article thread'), and enumerates the exact facets of that state: lifecycle status, current-revision flag, and sidebar rendering/dark/absent. This clearly differentiates it from broad list/search siblings like list_drifted or get_thread.

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

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

The description explicitly tells the agent when to use it: 'Use to answer "why is there no Key-Facts card on thread N?"'. This is a clear invocation context, though it does not explicitly state when not to use it or name alternative tools for comparison.

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