KonbiniAPI MCP

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

Annotations include readOnlyHint=false (write) but destructiveHint=false, so the tool is safe. The description adds no behavioral traits beyond the schema, but the schema covers parameter details. No contradiction 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 providing essential information: what it returns, dependency on another endpoint, and optional field parameters. No 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?

Given no output schema and 4 parameters, the description is mostly complete. It explains the source of highlight ID and optional field usage. However, it could mention error cases or authentication requirements.

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 explains parameters well. The description adds that fields are for 'payload reduction,' but this is partially redundant with the schema descriptions. Overall, minimal extra value, but baseline is high.

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 story items (images and videos) from a highlight reel. It distinguishes itself from siblings like 'instagram_get_user_highlights' by focusing on content retrieval rather than listing highlights. However, it does not explicitly differentiate from other story-related 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 mentions the highlight ID comes from the highlights list endpoint, providing usage context. However, it does not specify when to use this tool over alternatives, nor does it mention conditions like privacy or availability of highlights.

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

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

The description discloses the fixed page size (21) and that it returns 'recent' posts, which beyond annotations (readOnlyHint=false, destructiveHint=false) adds meaningful behavioral context. It does not mention rate limits or other constraints, but the disclosed details are valuable.

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

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

Two sentences, each serving a clear purpose: stating functionality and noting key constraints. No 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?

Given the moderate complexity (6 params, 1 required) and no output schema, the description covers the core purpose and key behavioral constraints (fixed page size, location ID format, payload reduction options). It could mention return format or pagination behavior, but the provided details are sufficient for an agent to invoke 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 the baseline is 3. The description adds context that locationId is 'numeric Facebook Places ID' and mentions projection_preset for payload reduction, but these are partially redundant with schema descriptions. No additional semantics beyond 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 it returns recent posts tagged at a location, distinguishing it from sibling tools like instagram_get_user_posts (posts by a user) and tiktok_get_tag_videos (different platform). The specific verb 'returns' and resource 'posts by location' leave no ambiguity.

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

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

The description provides clear context on when to use this tool (getting posts by location) and notes the fixed page size and location ID format. However, it does not explicitly exclude using sibling tools like instagram_get_user_posts for similar tasks, though the name and description sufficiently differentiate.

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 non-read-only and non-destructive. Description adds that it supports projection_preset and data_fields for payload reduction, which is useful but expected from parameter descriptions. No behavioral surprises.

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 concise sentences covering purpose, supported types, and payload reduction options. No 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?

Given no output schema, the description omits return structure but mentions 'media, captions, and engagement counts', which is sufficient for a list-like retrieval. Complete enough for a simple GET endpoint.

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 already covers 100% of parameters with descriptions. The description mentions shortcode format implicitly via 'Post shortcode (from instagram.com/p/{shortcode}/)' in schema. No additional meaning beyond 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 tool returns details for a single post by shortcode, and lists supported types (photos, videos, carousels). It differentiates from siblings like instagram_get_user_posts by focusing on a single post 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 implies when to use (for a single post) but does not explicitly contrast with alternatives like instagram_search_media or instagram_get_post_comments for broader search or comments.

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

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

Annotations indicate readOnlyHint=false (likely write, but description does not mention write behavior) and destructiveHint=false. Description adds value by noting fixed page size (platform limit) and included fields, which annotations do not cover. There is 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?

Description is three sentences, each adding distinct information: purpose, limitations (fixed page size), and configurable options. Slightly verbose for including field details already in schema, but generally efficient. Front-loaded with 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 no output schema, description explains return includes comment text, author info, likes, timestamps. However, it does not mention pagination cursor usage or that only top-level comments are returned (no replies). Sibling tools like 'tiktok_get_comment_replies' imply replies are separate. Overall adequate but could note cursor parameter 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?

Input schema has 100% description coverage, so baseline is 3. The description mentions 'projection_preset, data_fields, and item_fields' but adds no syntax or behavioral nuance beyond the schema. Semantics are adequately covered by 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?

Description clearly states it returns 'top-level comments on an Instagram post', specifying verb (returns), resource (top-level comments on Instagram post), and context (fixed page size, included fields). Sibling tools like 'tiktok_get_video_comments' or 'instagram_get_post' help distinguish, but the description itself is self-contained and 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?

Description explicitly mentions fixed page size (15) and supports pagination with cursor, implicitly guiding use for iterative fetching. However, no explicit alternatives or when-not-to-use guidance is provided, though the sibling set includes other comment-related tools (e.g., 'tiktok_get_comment_replies') and the tool's focus on top-level comments is clear.

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

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

Annotations indicate readOnlyHint=false and destructiveHint=false, but the description does not disclose that this is a read operation (since it returns profile info). However, it doesn't contradict annotations; it could be clearer about side effects.

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

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

The description is two sentences, but it could be more concise by removing redundant phrasing like 'public Instagram account' (implied by Instagram).

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

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

Given no output schema, the description could detail return format explicitly, but it lists key fields. It's adequate but not thorough for a social media profile tool.

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

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

Schema coverage is 100%, so the description adds some value by mentioning projection_preset and data_fields for payload reduction, but this is already implied by the schema descriptions.

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

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

The description clearly states it returns Instagram user profile information with specific fields like bio, follower counts, etc., and distinguishes from siblings that focus on posts, stories, or media.

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 limited usage guidance: it mentions looking up public accounts by username but does not explicitly state when not to use it or alternative tools for non-public information.

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?

Overall annotations are present but mostly default (false). The description adds behavior info about payload reduction via projection preset and fields. However, it does not disclose potential side effects or data handling beyond what annotations imply. 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 three sentences, each adding value: purpose, sibling reference, and field usage guidance. No wasted words, though it could be slightly more concise by merging the second and third 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?

Given that there is no output schema, the description mentions returning a list of highlights and suggests a related endpoint. It provides sufficient context for a listing tool with well-documented parameters, though user prerequisites (e.g., public profile or authentication) are not addressed.

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

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

Schema description coverage is 100%, so baseline is 3. The description adds value by mentioning projection_preset, data_fields, and item_fields for payload reduction, clarifying their purpose beyond the schema enums and 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 it returns the list of story highlight reels on a user's profile, using specific verbs ('Returns') and resource ('story highlight reels'). It distinguishes from sibling 'instagram_get_highlight_stories' by mentioning that endpoint is for getting individual stories within a highlight.

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 mentions using the highlight endpoint for individual stories, providing a clear alternative. However, it does not explicitly state when not to use this tool or provide prerequisites like authentication or rate limits.

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

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

Annotations are partially provided (readOnlyHint=false implies mutation is possible, but destructiveHint=false suggests non-destructive). The description adds that the tool is paginated and returns specific content types, but does not disclose rate limits, authentication needs, or any side effects beyond data retrieval. The annotations indicate it may not be purely read-only, but the description lacks detail on write behavior.

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

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

The description is concise at two sentences, front-loading key information (returns paginated list, max 12 posts, content types) before mentioning optional parameters. Every sentence adds value with 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 the moderate complexity (6 parameters, one required) and full schema coverage, the description is complete enough. It covers pagination, content types, and payload reduction options. There is no output schema, but the description hints at the response structure (orderedItems). The sibling context is large, but the tool's purpose is clear within that context.

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

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

The schema covers all parameters with descriptions and enums, achieving 100% coverage. The description mentions projection_preset, data_fields, and item_fields but does not add meaning beyond the schema. Baseline of 3 is appropriate since schema already explains each parameter sufficiently.

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 'Returns', the resource 'posts from an Instagram user's profile feed', and specifies the scope 'paginated list' with a maximum of 12 posts per page. It distinguishes from sibling tools by focusing on user profile posts, unlike location or highlight 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 implies usage for retrieving a user's feed posts and specifies a maximum of 12 per page. However, it does not explicitly state when not to use this tool or mention alternatives for other Instagram post types like reels or tagged posts, though siblings provide such distinction.

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

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

Annotations already provide readOnlyHint=false and destructiveHint=false, indicating a mutation but non-destructive operation. The description adds that the tool supports pagination and projection_preset for payload reduction, which is useful context beyond annotations. However, it does not discuss rate limits, authentication needs, or error behaviors, which would enhance transparency.

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

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

The description is three sentences that efficiently convey purpose, constraints, and key features. It is front-loaded with the main action and includes all critical details without unnecessary text. Slightly more structure (e.g., bullet points) could improve readability but is not required.

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 moderate complexity (6 parameters, all documented) and no output schema, the description covers the tool's purpose, pagination, and projection options. It mentions engagement counts but does not detail the return structure; however, the schema's parameter descriptions for data_fields and item_fields provide some insight into output fields. The description is complete enough for typical 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?

Schema description coverage is 100%, so the schema already documents all parameters. The description adds contextual detail by mentioning projection_preset, data_fields, and item_fields for payload reduction, but these are also described in the schema. Thus, the description adds marginal value; 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 returns a paginated list of reels from an Instagram user's profile, specifying the resource (reels), source (user's profile), and key fields (video URLs, captions, engagement counts), which distinguishes it from sibling tools like Instagram posts or stories.

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 (to retrieve user reels) and mentions the maximum page size (12) and pagination via cursor. However, it does not explicitly state when not to use it or differentiate from other Instagram tools, though the tool name and sibling list imply its specific niche.

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?

Discloses key behavioral traits: maximum 12 posts per page, includes full post details and engagement counts, supports payload reduction. Annotations indicate not read-only (readOnlyHint false), not destructive (destructiveHint false), and idempotentHint false. Description does not contradict annotations.

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

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

Three sentences, no fluff. Front-loaded with main purpose. Could be slightly more structured but overall concise.

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?

Tool has 6 parameters with 100% schema coverage, no output schema, and moderate complexity. Description covers main behavior (tagged posts, limit, payload reduction) adequately for agent selection and 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% but description adds minimal semantics beyond schema. It mentions projection_preset and data_fields/item_fields for payload reduction, which adds value, but does not elaborate on their usage in detail. Scalars are adequately described in 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?

Clearly states it returns Instagram posts where the user is tagged by others. Verb 'get' plus resource 'user tagged posts' is specific. Distinguishes from sibling tools like instagram_get_user_posts by specifying 'tagged' posts.

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?

Implies usage for retrieving tagged posts but does not explicitly say when to use this over alternatives like instagram_search_media or instagram_get_user_posts. No when-not-to-use guidance, though sibling names provide some context.

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

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

Annotations show no read-only, idempotent, or destructive hints (readOnlyHint, idempotentHint, destructiveHint all false). The description adds transparency by stating it returns video details (captions, engagement) and supports payload reduction features (projection_preset, data_fields, item_fields). This complements annotations, which are sparse. 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?

Description is three concise sentences with no wasted words. Each sentence adds unique value: what it does, result limit, return details, and payload reduction options.

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

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

Given the tool has no output schema and 6 parameters (1 required), the description covers the core functionality, pagination limit, and customization options. It is missing explicit return format details (e.g., structure of results), but the description of 'returns video details including captions and engagement counts' provides sufficient context. A slightly lower score due to lack of output schema and no mention of error handling or rate limits.

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 the schema already documents all parameters. The description adds context that the tool supports projection_preset, data_fields, and item_fields for payload reduction, which is a helpful summary. However, it does not detail how each parameter interacts. 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 searches for reels and videos by keyword. It differentiates from siblings like instagram_get_user_reels by focusing on keyword search, but doesn't explicitly distinguish from other search tools (though none exist in siblings for Instagram).

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

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

The description implies usage for keyword-based search of reels and videos. It mentions a maximum of 24 results per page and pagination via cursor. However, it does not explicitly state when to use this tool versus alternatives like instagram_get_user_reels or instagram_search_media (only one search tool). No when-not-to guidelines.

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 readOnlyHint=false and destructiveHint=false, so the description adds little behavioral context beyond the retrieval nature. It mentions supported fields for payload reduction, which is useful but does not disclose side effects or error states.

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

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

The description is two sentences long with no extra words. It front-loads the primary function and then mentions customization options, making it efficient and clear.

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 retrieval tool with no output schema, the description covers the returned data types and customization options. It is fairly complete but could be improved by explicitly noting that it returns a single comment and requires postId/commentId.

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 already present for each parameter. The description adds minimal extra meaning, only stating that projection_preset and data_fields reduce payload. 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 states it returns a comment with specific fields (author, scores, reply presence, media) and mentions projection_preset/data_fields. It clearly indicates the tool is for fetching a single comment, which differentiates it from siblings like reddit_get_comment_replies or reddit_get_post_comments, though not explicitly stated.

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

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

No guidance is provided on when to use this tool versus alternatives such as reddit_get_comment_replies or reddit_get_post_comments. The description merely states what it does without context for selection.

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

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

Annotations indicate readOnlyHint=false and openWorldHint=true. The description adds context about cursor-based pagination and payload reduction but does not clarify potential side effects or authentication needs. 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 two sentences, front-loaded with the primary action and pagination method, then mentions payload reduction options. Every sentence adds value 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?

Despite no output schema, the description does not explain the return structure or pagination details. The tool has 7 parameters, and while the main features are covered, some aspects like ordering or cursor usage are left to 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 coverage is 100%. The description mentions projection_preset, data_fields, and item_fields for payload reduction, adding some meaning beyond the schema. However, it does not explain all parameters in detail, which is acceptable given coverage.

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

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

The description clearly states the tool returns direct replies to a Reddit comment using cursor-based pagination, distinguishing it from sibling tools like reddit_get_comment (single comment) and reddit_get_post_comments (top-level 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 does not explicitly state when to use this tool versus alternatives. It implies usage when you have postId and commentId, but lacks guidance on prerequisites or when not to use it.

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

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

Annotations provide some safety info; the description adds the cost per ID, which is a key behavioral trait, but doesn't discuss other side effects or performance.

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 that are front-loaded, with no wasted words; every sentence adds value.

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

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

Sufficient for a batch retrieval tool given output schema is absent; mentions limits and cost, but could hint at 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 coverage is 100%, so description adds minimal extra meaning beyond noting payload reduction; 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 returns Reddit comments by ID in batch, distinguishing it from single-comment or post-comments 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 context is clear (retrieving multiple comments by ID), but no explicit when-not or alternatives are mentioned, though siblings imply different use cases.

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 (readOnlyHint=false) indicate possible mutation but name suggests read. Description adds no behavioral traits beyond annotations, missing details like idempotency or side effects. Acceptable due to annotations covering 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?

Two sentences: first states purpose and examples, second introduces payload reduction features. No unnecessary words, 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?

Lacks description of return structure or pagination behavior. With no output schema, more detail on output format or cursor usage would improve completeness. Acceptable for a simple feed tool but could be better.

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%, providing baselines. Description adds value by explaining that projection_preset, data_fields, and item_fields support 'payload reduction', which enhances understanding beyond schema descriptions.

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

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

Clearly states verb 'Returns posts' and resource 'top-level Reddit feed' with explicit examples of feed kinds (best, hot, new, top, rising, controversial). Distinguishes from sibling tools like reddit_get_subreddit_posts by specifying 'top-level'.

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?

Implies usage for global feeds but does not explicitly state when to use or avoid alternatives like reddit_get_subreddit_posts or reddit_search_posts. No direct guidance on context or 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?

Annotations state readOnlyHint=false, but the description implies a read-only operation ('returns a post'). This is a contradiction. No additional behavioral details (e.g., error handling, authentication needs) are disclosed.

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

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

Single sentence front-loaded with the main action and supported features. No waste; every word contributes to clarity.

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 get tool with no output schema, the description lists key return fields (title, body, author info, engagement, attachments). It lacks error handling or edge-case behavior, but is largely adequate.

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

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

Schema coverage is 100% with clear parameter descriptions. The description adds marginal value by explaining the purpose of projection_preset and data_fields for payload reduction, but doesn't go beyond what the schema already conveys.

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 returns a public Reddit post with specific fields (title, body, author info, engagement counts, attachments) and mentions payload reduction via parameters. This distinguishes it from sibling tools that fetch other entities like comments or subreddits.

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

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

No guidance on when to use this tool versus alternatives (e.g., reddit_get_posts_batch for multiple posts). No when-not-to-use or exclusionary conditions 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?

Discloses key behaviors: cursor-based pagination and ordering options. Annotations already indicate non-destructive nature. Does not contradict annotations. Lacks details on rate limits or authentication, but 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?

Three short sentences, each carrying essential information. The main purpose is front-loaded, and no redundant or wasteful wording. Ideal conciseness.

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

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

Given the complexity (7 parameters, no output schema), the description adequately covers core function, ordering, pagination, and payload reduction. Could add brief mention of return structure, but overall sufficient.

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

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

Schema description coverage is 100%, but the description adds value by explaining the purpose of projection_preset, data_fields, and item_fields for payload reduction, which goes beyond the individual parameter 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 'Returns top-level comments on a Reddit post', specifying the resource (comments) and action (get). It distinguishes from siblings like 'reddit_get_comment_replies' by emphasizing 'top-level comments' and 'on a Reddit 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 implies usage for top-level comments and mentions ordering and pagination, but does not explicitly state when to use this tool over alternatives like 'reddit_get_comment_replies' or 'reddit_get_comments_batch', nor does it provide prerequisites or exclusions.

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

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

Annotations declare readOnlyHint=false and destructiveHint=false, so the behavior is not fully transparent. The description adds that it supports payload reduction parameters, but does not explain other behaviors like rate limits or authentication. 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 two sentences: the first defines the core purpose, the second notes optional parameters for payload reduction. It is front-loaded, concise, and contains no unnecessary 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 low complexity (simple retrieval of duplicates) and full schema coverage of parameters, the description is mostly adequate. However, it lacks explanation of the output structure, though no output schema is provided. The pagination parameters are documented 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 coverage is 100%, so the baseline is 3. The description mentions projection_preset, data_fields, and item_fields for payload reduction, but adds no new meaning beyond the schema's descriptions. The schema already documents these parameters adequately.

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 returns duplicate submissions and crossposts for a Reddit post. The title 'Reddit: Get duplicate posts' is straightforward. It distinguishes from sibling tools like reddit_get_post (single post) and reddit_get_post_comments (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 implies usage by stating what it returns, but it does not explicitly guide when to use this tool versus alternatives. There is no mention of when-not or alternative tools among the 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?

The description says 'Returns' implying a read operation, but annotations set readOnlyHint=false, contradicting the description. No additional behavioral traits (e.g., side effects, auth needs, rate limits) are disclosed beyond the 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 sentences (24 words), front-loaded with the primary purpose and limit, followed by cost and features. Every sentence adds information without 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 no output schema, the description should clarify return structure (e.g., array of posts) but does not. Parameter coverage is high, but the missing output context moderately reduces completeness.

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

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

Schema coverage is 100% with descriptions for all parameters. The description adds value by noting cost ('1 credit per ID submitted') and payload reduction ('supports projection_preset and data_fields'), which enriches understanding beyond schema details.

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 'Returns up to 100 Reddit posts by ID in a single request', providing a specific verb, resource, and batch limit, which distinguishes it from sibling tools like reddit_get_post (single post) and reddit_get_comments_batch (different 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 mentions cost per ID but provides no guidance on when to use this tool versus alternatives like reddit_get_post for single IDs or other batch tools. It lacks explicit when-to-use, when-not-to-use, or alternative suggestions.

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?

Specifies 'public' metadata, clarifying scope, and mentions payload reduction options. Annotations provide no contradiction; description adds context beyond structured fields.

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

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

Two efficient sentences with no wasted words. First sentence defines purpose, second adds capability details.

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

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

For a simple metadata tool, it lists key return fields and payload options. No output schema or error handling mentioned, but adequate given low complexity and sibling 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 already covers all parameters with descriptions (100% coverage). Description adds no new semantic value beyond summarizing payload reduction, 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 returns public subreddit metadata (title, description, icon, banner, subscriber count) and distinguishes itself from sibling tools like reddit_get_post or reddit_get_feed by focusing on subreddit-level 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?

No guidance on when to use this tool versus alternatives (e.g., reddit_get_subreddit_posts or reddit_get_subreddit_comments). Missing explicit when/when-not scenarios.

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

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

Description mentions ordering, time windows, and payload reduction, adding behavioral context beyond annotations. However, it does not disclose potential side effects (though readOnlyHint is false), rate limits, or authentication requirements. Annotations provide limited 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?

Two sentences that are front-loaded with essential purpose and key features. No redundancy or unnecessary detail.

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

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

For a tool with 8 parameters and no output schema, the description covers core functionality (returns comments, ordering, payload reduction). It omits pagination details but is sufficient for selection decisions.

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 baseline is 3. Description adds value by explaining ordering supports 'hot, new, top, and controversial', time windows for top/controversial, and payload reduction via projection_preset/data_fields/item_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?

Description clearly states it returns public comments from a subreddit, with a specific verb and resource. It distinguishes from sibling tools like reddit_get_subreddit_posts and reddit_get_post_comments by focusing on subreddit-level 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?

No explicit guidance on when to use this tool versus alternatives like reddit_get_post_comments or reddit_get_comment. The description implies usage for browsing a subreddit's comments but does not state when-not-to-use or provide alternatives.

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

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

Annotations already provide some behavioral traits (readOnlyHint=false, destructiveHint=false). The description adds context about ordering and payload reduction but does not disclose additional behavioral details like rate limits, authentication needs, or response characteristics. The contradictory readOnlyHint (false vs. read-only nature) is flagged separately.

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, concise and front-loaded with the main purpose. It avoids unnecessary fluff, though could be slightly more structured for readability.

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

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

Given the tool has 8 parameters and no output schema, the description covers core functionality and projection options but omits pagination (cursor) details, default values, and return format. It is adequate but incomplete.

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

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

Schema coverage is 100% with descriptions for all parameters. The description summarizes ordering and projection options but does not add new meaning beyond the schema. Baseline 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?

The description clearly states the verb 'Returns' and the resource 'public posts from a subreddit'. It lists ordering options and projection features, making the tool's function unambiguous and distinct from sibling tools like reddit_get_subreddit or reddit_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 implies usage (fetching subreddit posts with various orderings) but does not explicitly state when to use this tool over alternatives like reddit_get_feed or reddit_search_subreddit_posts. No exclusions or when-not-to-use 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?

Description claims it 'Returns' data (read-only), but annotation readOnlyHint=false contradicts this. This is a serious inconsistency, as the tool is clearly a GET operation. Score 1 due to 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 concise sentences, front-loaded with purpose. Efficient but could be slightly more 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?

No output schema, and description does not detail the structure of the returned rules. Adequate but incomplete for an agent to fully understand the response format.

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 baseline is 3. Description mentions parameters but adds no new information beyond what the schema already provides (e.g., enums, 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?

Clearly states 'Returns structured community rules for a subreddit.' Specific verb and resource. Distinct from sibling tools like get_subreddit 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?

No explicit guidance on when to use this tool vs alternatives. Implicitly distinguished by its focus on rules, but no exclusion criteria or context 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?

Adds credit cost and payload reduction options beyond annotations. No contradiction, though readOnlyHint=false could be clarified.

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 waste: first states purpose and limit, second adds cost and features.

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?

Covers core purpose, cost, and optional filters. Missing error handling or rate limits, but adequate for simple batch retrieval.

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 all parameters with descriptions; description adds minimal value beyond reinforcing payload reduction features.

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 returns up to 100 subreddits by ID in a single request, distinguishing it from single-subreddit or other sibling tools.

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

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

Implicitly suggests use for batch retrieval with 'single request' and credit cost, but lacks explicit when-not-to-use or 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?

The description implies a read-only operation ("Returns sticky posts"), but the annotations set readOnlyHint=false, indicating it may have side effects. This is a direct contradiction, severely undermining transparency.

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

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

The description is efficient with two sentences and no extraneous information. Could be more structured but is concise.

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 basic function and payload reduction, but lacks details on return format, error conditions, or rate limits. With no output schema, more context would be helpful.

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 context that projection_preset, data_fields, and item_fields are for payload reduction, which goes beyond the schema descriptions. However, this is minimal; baseline is 3 due to 100% schema coverage.

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

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

The description clearly states it returns sticky posts for a subreddit across all available slots, using a specific verb and resource. This distinguishes it from sibling tools like reddit_get_subreddit_posts.

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 on when to use this tool versus alternatives. No prerequisites or contextual usage hints 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?

Annotation contradiction: readOnlyHint is false, but the description states 'Returns public Reddit user profile information' which is a read-only operation. This inconsistency undermines transparency. No additional behavioral traits are disclosed beyond the contradictory annotation.

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

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

Two sentences, front-loaded with purpose. No unnecessary verbiage. 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?

No output schema exists, so the description should explain return format. It lists some fields (bio, avatar, etc.) but does not describe the overall structure or any pagination. Partially 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 100% with clear descriptions for each parameter. The description adds minimal value by stating it 'Supports projection_preset and data_fields for payload reduction,' but this does not provide new meaning beyond the schema.

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

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

Description clearly states the tool returns public Reddit user profile information with specific attributes (bio, avatar, verification flags, account creation date). It also mentions payload reduction options (projection_preset, data_fields), distinguishing it from siblings that return comments, posts, etc.

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

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

The description does not explicitly state when to use this tool vs alternatives. While the name and context imply it's for general profile info, there is no guidance on when not to use it or which sibling tools might be better for specific needs.

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

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

The description contradicts annotations: readOnlyHint is false, implying the tool may write, but the description only describes a read operation. It does not disclose any other behavioral traits 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 two sentences, front-loaded with the main purpose, and includes key features without fluff. 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 8 parameters and no output schema, the description covers functionality well. It mentions payload reduction but lacks explicit return structure details, which is partially addressed by item_fields enum.

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%, baseline 3. The description adds value by explaining ordering, time windows, and payload reduction parameters, which go beyond raw enum values.

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 public comments by a Reddit user, specifying verb and resource. It also lists supported orderings and payload reduction options, distinguishing it from sibling tools like reddit_get_user_posts.

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

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

The description does not explicitly guide when to use this tool versus alternatives like reddit_get_user_overview or reddit_get_user_posts. It lists ordering options but lacks usage context or exclusions.

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

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

The description is consistent with a read operation, but annotations set readOnlyHint=false, creating a contradiction. No additional behavioral details are provided beyond what is in 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?

Two sentences with no filler, front-loaded with the main purpose, and each sentence adds distinct 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?

Given 8 parameters and no output schema, the description is brief. It does not explain pagination, defaults, or the structure of the returned feed, which could help agents use it effectively.

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 baseline is 3. The description mentions ordering and time windows but adds minimal extra meaning beyond the schema, such as the phrase 'payload reduction'.

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 returns a mixed feed of posts and comments, distinguishing it from sibling tools like reddit_get_user_posts and reddit_get_user_comments which return only one type.

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 for a combined feed but does not explicitly state when to use this tool versus the more specific siblings, nor does it mention any prerequisites or 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?

Description describes a read operation ('Returns public posts'), but annotations set readOnlyHint=false, indicating possible side effects. This contradiction undermines transparency. The description does not address the discrepancy.

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 wasted words. Front-loaded purpose, followed by key details (ordering, time windows, payload reduction). Perfectly sized for quick comprehension.

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?

Covers essential behavior: public posts, ordering, time windows, payload reduction. Pagination (cursor) is in schema but not described. No mention of rate limits or authentication, but acceptable given sibling tools and annotations (openWorldHint).

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 baseline is 3. Description adds value by explaining ordering (hot/new/top/controversial) and time windows, and introduces payload reduction concepts (projection_preset, data_fields, item_fields) beyond schema definitions.

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

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

Description clearly states 'Returns public posts submitted by a Reddit user' with specific verb-resource pairing. Differentiates from sibling tools like reddit_get_user (user info) and reddit_get_subreddit_posts (subreddit posts) by targeting user-scoped posts.

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 mentions ordering and time windows but lacks explicit when-to-use guidance versus sibling tools such as reddit_get_user_comments. Does not state when not to use or provide 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?

The description claims the tool 'Searches' (read-only behavior), but the annotation readOnlyHint=false indicates the tool might not be read-only. This is a direct contradiction. Additionally, no detailed behavioral traits like pagination or authentication are disclosed.

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

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

The description is three sentences, each adding value. It is front-loaded with purpose and followed by key features. 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 8 parameters and no output schema, the description does not explain pagination (cursor), default/max count, or return structure. It mentions payload reduction but omits important usage details.

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 the description does not need to add much. It reaffirms the sorting and payload reduction options but does not provide new meaning beyond the schema.

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

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

The description clearly states the verb 'Searches' and the resource 'public Reddit posts across the platform.' It lists supported sorting and time windows, and mentions payload reduction features, effectively distinguishing it from sibling tools like reddit_search_subreddit_posts.

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 stating it searches across the platform and supports various sort orders and time windows. However, it does not explicitly contrast with alternatives or specify 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?

The description adds behavioral context beyond annotations, such as support for payload reduction via projection_preset, data_fields, and item_fields, and optional time windows. Annotations already indicate non-idempotent and non-destructive behavior. No contradictions; the description enriches agent understanding.

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

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

Two sentences with the main purpose front-loaded and no unnecessary words. It efficiently covers key features: search scope, sorting, time windows, and payload reduction. Ideal length for quick comprehension.

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 9-parameter tool with no output schema, the description covers the main purpose, sorting, time windows, and payload reduction. It mentions subreddit naming format and sort orders. Missing explicit mention of pagination (cursor) and count parameter, but these are in the schema. The description 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 100%, so baseline is 3. The description groups payload reduction parameters and summarizes sort/time options, but does not add detailed semantics beyond what the schema enumerates (e.g., defaults, enum values). It provides a helpful overview but no significant extra 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 'Searches public Reddit posts within a subreddit', specifying the verb (search), resource (subreddit posts), and scope (within a subreddit). It lists supported sort orders and time windows, effectively distinguishing it from sibling tools like reddit_search_posts (cross-subreddit) and reddit_get_subreddit_posts (no query filter).

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 implicitly indicates when to use the tool (searching within a subreddit) and lists sorting and time options, but does not explicitly state when not to use it or name alternative tools. Clear context is provided, but exclusions 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?

Description says 'Searches' (read-only), but annotations set readOnlyHint=false, indicating potential writes. This contradicts the description. No additional behavioral 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, no fluff. Could be slightly more informative without being verbose, but effective.

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?

No output schema provided. Description omits pagination behavior (cursor, count), default values, and output structure. With 6 parameters and no output schema, more detail is needed.

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

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

Schema covers all parameters with descriptions (100% coverage). The description adds minimal value by naming three parameter groups (projection_preset, data_fields, item_fields) for payload reduction, but doesn't explain them further.

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 ('searches') and resource ('public Reddit subreddits'), distinguishing it from sibling tools like reddit_search_posts and reddit_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?

No guidance on when to use this tool versus alternatives (e.g., reddit_search_subreddit_posts or reddit_search_posts). The description only mentions payload reduction features, not usage context.

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

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

The description adds the behavioral trait of supporting payload reduction via projection_preset, data_fields, and item_fields. Annotations already provide safety cues; however, the description does not contradict annotations but also does not substantially extend transparency beyond what annotations and schema offer.

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 clear front-loading of purpose and a concise second sentence about payload reduction. No wasted words or redundant information.

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

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

No output schema is provided, and the description does not explain the response format, pagination behavior, or field usage details. While the schema covers parameter descriptions, the tool's overall behavior and results remain under-described for an agent to fully understand usage consequences.

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

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

Schema description coverage is 100%, with all 6 parameters having descriptions. The tool description mentions three parameters by name but adds no new meaning beyond the schema. Baseline 3 is appropriate as 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 clearly states the tool searches public Reddit users across the entire platform, using a specific verb and resource. This distinguishes it from sibling tools like reddit_search_posts which target different resources.

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

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

The description implies this tool is used when searching for users, but does not explicitly mention when to use or avoid it compared to alternatives. No exclusions or when-not-to-use 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 are minimal (no readOnlyHint, idempotentHint, or destructiveHint), so the description carries the transparency burden. It accurately describes a non-destructive read operation (returning metadata), which is consistent with the annotations. Additional details about payload reduction features (projection_preset, data_fields) provide beyond-basic context.

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

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

The description is concise (two sentences) and front-loaded with the core purpose. Every sentence adds value: first states what it returns, second explains how to access and optimize payload. 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 that there is no output schema, the description adequately summarizes return fields. It covers primary metadata and reduction options, which is sufficient for audio metadata retrieval. However, it could mention pagination or rate limits if applicable, and does not explain that the tool is read-only (though annotations hint at 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 coverage is 100% and parameters are well-described in the schema. The description adds minimal parameter semantics by mentioning 'audio ID' and 'projection_preset/data_fields for payload reduction', but does not significantly enhance understanding 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 specifies a clear verb ('Returns') and resource ('metadata for a TikTok audio track'), listing exact fields like title, artist, duration, usage count, and cover image. It also clarifies the lookup method ('by its audio ID') and mentions payload reduction features, distinguishing it from sibling tools that focus on videos or 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 usage for retrieving audio metadata but offers no guidance on when to use this tool versus alternatives like tiktok_get_audio_videos (which retrieves videos using that audio). No exclusion criteria or alternative tool names 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 specify readOnlyHint=false (not read-only, but not explicitly destructive), destructiveHint=false, idempotentHint=false. Description adds pagination details (max 30 per page) and mentions payload reduction options. No annotation contradiction. Could benefit from mentioning rate limits or whether this is a write operation.

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

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

Three sentences – clear, no fluff. Front-loaded with purpose and limit. Could be slightly more structured (e.g., list format for parameters).

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

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

Tool has 6 parameters with 100% schema coverage and no output schema. Description covers pagination and field selection. Lacks return value description, but no output schema exists. Adequate for this complexity.

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

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

Schema coverage is 100%, so schema already describes all parameters. Description adds value by summarizing the 'payload reduction' purpose of projection_preset, data_fields, item_fields, but does not provide examples or further explanation. 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 clearly states the tool returns a paginated list of TikTok videos using a specific audio track. The verb 'get videos with audio' distinguishes it from other TikTok tools like tiktok_get_video (single video) or tiktok_get_tag_videos (videos by tag).

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 mentions 'Discover trending content by sound or music' implying when to use it. However, no explicit alternatives or when-not-to-use guidance is provided. Sibling tools indicate other video listing tools (by user, tag, etc.) but description does not differentiate.

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

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

Annotations indicate readOnlyHint=false (potential mutation? but description suggests read-only), openWorldHint=true (output may vary), and destructiveHint=false. The description adds context about pagination limits and payload reduction options, which are not in annotations. No contradiction detected.

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 (three sentences) and front-loaded with the key purpose. Every sentence adds value, though it could be slightly more structured (e.g., bullet points).

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 6 parameters, 100% schema coverage, no output schema, and the complexity of TikTok collections, the description adequately states the purpose and pagination limit. It could mention the default projection preset and possible return structure, but is sufficient 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 coverage is 100%, so baseline is 3. The description mentions projection_preset, data_fields, and item_fields for payload reduction, but does not add significant meaning beyond the schema's descriptions. The parameters are well-documented in the schema.

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

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

The description clearly states the tool returns a paginated list of videos in a TikTok collection, including full video details and engagement counts. It distinguishes itself from sibling tools like tiktok_get_user_videos and tiktok_get_tag_videos by specifying the resource type (collection).

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

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

The description implies usage for fetching videos from a playlist or mix, and specifies a maximum of 35 per page, which guides pagination. However, it does not explicitly state when not to use this tool or mention alternatives among the many tiktok_ 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 indicate it's not readonly (readOnlyHint: false), not idempotent, and not destructive. The description adds pagination details and payload reduction, but doesn't disclose rate limits, authentication needs, or error behavior. Acceptable given 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?

Three sentences, each providing key information: functionality, limits, and customizability. No filler. Could be slightly more concise by combining sentences, but efficient 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 the tool's complexity (7 parameters, pagination, projection presets) and no output schema, the description covers core functionality but lacks information about return format structure (e.g., how pagination appears in response). Adequate but not 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 100%, so parameters are adequately described in the schema. The description adds context about maximum 50 per page and the purpose of projection fields, but does not add significant meaning beyond the schema. 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?

Clearly returns a paginated list of replies to a TikTok comment, with specific details on what's included (author info, likes, timestamps). Distinguishes itself from sibling tools like tiktok_get_video_comments, but the purpose is still clear and specific.

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

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

The description states maximum per page and mentions payload reduction parameters, but does not explicitly state when to use this vs. other comment-related tools (e.g., tiktok_get_video_comments). Implied usage but no exclusions or alternative recommendations.

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 false, openWorldHint true, no destruction; description adds that the tag name is automatically resolved to an internal ID, which is a key behavioral detail not in annotations. It also mentions support for projection_preset and field reduction, which helps set expectations about payload control.

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

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

Description is three sentences, all relevant and front-loaded with the core purpose. Every sentence adds value, but the mention of projection_preset could be slightly more concise.

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 schema covers all parameters and annotations provide key hints, the description is adequate. The tool is a straightforward retrieval with no output schema, so the description covers the essential behavior (tag resolution, payload reduction) without 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%, so the description adds limited value beyond the schema. The description briefly mentions projection_preset and data_fields/item_fields, but does not elaborate on their usage or defaults beyond what's in the schema.

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

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

The description clearly states the tool returns TikTok videos associated with a hashtag or challenge, using specific verbs "returns" and "resolved." It distinguishes from siblings like tiktok_get_audio_videos and tiktok_get_collection_videos by specifying the resource type (tag videos).

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

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

The description implies usage for fetching tag-associated videos, but does not explicitly state when not to use it or compare with alternatives like tiktok_search_videos. However, the sibling list provides context for an agent to infer differentiation.

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 readOnlyHint: false (unlikely read-only since fetching profile), openWorldHint: true (no fixed set of data), idempotentHint: false (may not be idempotent), destructiveHint: false (safe). The description adds behavioral context about payload reduction via projection_preset and data_fields, which is helpful 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?

Three sentences covering purpose, usage, and advanced features. No wasted words. Information is front-loaded.

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

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

For a simple profile-lookup tool with good schema coverage and no output schema, the description is adequate. It covers purpose, parameters, and a tip. Could mention that data_fields works with projection_preset but still complete enough.

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 the schema already documents all 3 parameters. The description adds value by explaining the benefit of projection_preset and data_fields ('payload reduction'), which goes beyond the enum and type info.

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 TikTok user profile information including specific fields (bio, follower counts, verification status, profile picture) and explains the lookup mechanism (by username). It also distinguishes from sibling tools by focusing on the top-level profile rather than videos or collections.

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 (to get user profile info) but doesn't explicitly state when not to use it or provide alternatives among the many TikTok sibling tools. However, given the diverse sibling names, the purpose is relatively 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 indicate openWorldHint, but no contradictory or additional behavioral details missing beyond annotations. Description includes pagination and payload reduction features.

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, efficiently front-loads key output and customizations. No wasted words.

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

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

Given no output schema, description covers purpose, pagination, and customization options adequately but lacks explicit enumeration of return fields or error conditions.

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 description adds marginal value. The description mentions projection_preset, data_fields, and item_fields but does not add detail beyond 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?

Description clearly states it returns paginated collections (playlists/mixes) on a TikTok user's profile with specific fields. However, it does not differentiate from sibling tools like tiktok_get_user_videos or tiktok_get_collection_videos.

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

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

Implies usage for retrieving user collections, but no explicit guidance on when to use this vs other tiktok_get_user_* tools or 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 indicate openWorldHint=true (result may vary) and destructiveHint=false, which aligns with a read-like operation. The description mentions pagination and max 30, but doesn't clarify rate limits or potential errors beyond 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?

Description is a single short paragraph with key details upfront. Could omit 'projection_preset, data_fields, and item_fields for payload reduction' as those are in schema, but overall concise and well-structured.

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

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

Given no output schema and 6 parameters, the description covers the basic purpose and key constraints. Lacks description of return structure or pagination details (e.g., how cursor works). Adequate but not 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 100%, so all parameters are documented. The description adds context for projection_preset and data_fields/item_fields for payload reduction, but these are also in schema. No additional meaning beyond 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 it returns a paginated list of followers of a TikTok user, with specifics like max 30 per page and profile details. This distinguishes it from sibling tools like tiktok_get_user_following or tiktok_get_user_videos.

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

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

The description includes max per page and mention of projection_preset, but does not compare alternatives or state when not to use it. No explicit guidance on when to prefer this over tiktok_get_user_following, for example.

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

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

Annotations indicate readOnlyHint=false (so may not be read-only) but destructiveHint=false, so safe. Description adds that it returns paginated list with profile details. Discloses max 30 per page. 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 extraneous info. Front-loaded: purpose, pagination limit, includes profile details, payload reduction options. Every sentence is 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?

Given no output schema, description explains return includes paginated list with profile details. Could mention that cursor is string and default 0, but schema already covers that. Overall sufficient for a list endpoint.

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% but description adds value by explaining payload reduction via projection_preset, data_fields, item_fields. Also clarifies max count (30) and default cursor.

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 it returns a paginated list of accounts a TikTok user follows, differentiating from sibling tools like tiktok_get_user_followers (get followers) and tiktok_get_user (get user profile). Describes specific resource: user's following list.

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 mentions maximum 30 per page and pagination via cursor. Does not explicitly state when not to use or compare to alternatives, but the sibling list is large and context implies this is for listing following.

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

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

Annotations indicate readOnlyHint=false and destructiveHint=false, but the description's mention of private likes returning empty list adds context. However, it does not disclose potential rate limiting or data freshness. The description partially compensates for missing behavioral details.

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 and 28 words, concise and front-loaded with the core purpose. The second sentence adds useful caveats and feature hints without bloat.

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

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

Given the schema's comprehensive parameter descriptions and no output schema, the description covers the main behavioral note (private likes) and the payload reduction feature. However, it lacks information about pagination behavior beyond an empty list case and does not mention typical error conditions.

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?

All parameters have descriptions in the schema (100% coverage), so the description does not need to add parameter details. It mentions three optional fields (projection_preset, data_fields, item_fields) but does not explain the projection_preset options beyond listing them.

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 returns a paginated list of liked videos for a TikTok user. While it distinguishes itself from sibling tools like tiktok_get_user_videos, it could more explicitly differentiate from other user-specific endpoints.

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 mentions that private likes result in an empty list, which helps set expectations, but it does not provide explicit guidance on when to use this versus other tools, such as tiktok_get_user_videos, or mention prerequisites like authentication.

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?

Discloses read-only behavior (consistent with readOnlyHint=false but openWorldHint=true) and that it returns 404 if not live, which is important for error handling. Annotations already indicate no destructive action, but description adds specific error condition.

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?

Only three sentences, each adding distinct value: what it returns, special error case, and available parameter options. No redundancy.

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

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

Given no output schema and simple parameters, description is sufficient. Could mention that it requires username string, but that's obvious from required field. Missing mention of rate limits or auth, but acceptable for a read operation.

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

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

Schema description coverage is 100%, so baseline is 3. Description mentions projection_preset and data_fields for payload reduction but doesn't add meaning beyond schema (e.g., no examples of how to use them). Adequate.

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 it returns current live stream for a user, including specific data (stream URLs, viewer count) and error condition (404 if not live). Distinguishes from siblings like tiktok_get_user or tiktok_get_user_videos by focusing specifically on live streaming.

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?

Implies usage when you need live stream data for a specific user. While it doesn't explicitly contrast with siblings, the description and name make it clear this is for live streams only, not regular videos or user info.

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 destructiveHint=false and readOnlyHint=false (though readOnlyHint is not explicitly set), so the description doesn't need to reaffirm safety. It adds value by noting that private reposts return empty lists, which is a key behavioral trait. 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?

Short and front-loaded: three sentences. The first sentence states the purpose, the second adds a caveat, the third lists optional field filtering. No fluff, though it could be slightly more 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 7 parameters (1 required), 100% schema coverage, and no output schema, the description adequately explains the main behavior and edge case (private reposts). It provides essential cues for pagination (cursor) and payload reduction, making it sufficient 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 covers 100% of parameters, so baseline is 3. The description does not add additional meaning beyond the schema descriptions, e.g., it doesn't explain the default pagination behavior or format. So no extra credit.

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 it returns a paginated list of reposted videos for a TikTok user. The description distinguishes it from sibling tools like tiktok_get_user_videos (user's own videos) and tiktok_get_user_likes (liked videos) by specifying 'reposted'.

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 a usage note about private reposts leading to empty results, which helps agents handle failures. It also mentions support for projection_preset and field filtering for payload reduction, but does not explicitly contrast with alternative tools for fetching user content.

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?

Discloses that stories expire after 24 hours and include images/videos with engagement data. Annotations show readOnlyHint=false but this is consistent with a read operation (stories are fetched not modified). 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?

Two sentences, each adding distinct value: purpose+expiration, then payload details. Efficient, though the acronym 'TikTok' could be considered redundant with the tool name.

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

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

Given 6 parameters with 100% schema coverage, no output schema, and no nested objects, the description adequately covers purpose, constraints, and custom fields. Missing return structure but not critical when schema covers 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 descriptions already cover 100% of parameters, so baseline is 3. Description adds value by naming engagement data and payload reduction via presets/fields, clarifying purpose of projection presets beyond enum listing.

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 it returns a paginated list of active stories for a TikTok user. Distinguishes from siblings like tiktok_get_user_videos by specifying 'stories' and adding expiration detail.

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?

Implies usage context (fetch active stories) but does not explicitly exclude alternatives or provide when-not-to-use guidance. However, the expiration note and pagination info help the agent decide when to call.

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 this is not read-only (readOnlyHint false), open-world (openWorldHint true), not idempotent, and not destructive. The description adds behavioral insights: maximum 35 videos per page, supports pagination via cursor, and payload reduction via projection_preset and fields. This adds value beyond annotations, but could disclose rate limits or API-specific constraints.

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

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

The description is three sentences: purpose, sorting options, max videos, and payload reduction. It is concise and front-loaded with the core purpose. One sentence could be omitted if the schema already covers parameters, but it remains lean and efficient.

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

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

Given no output schema exists, the description should not explain return values in detail. It covers the key purpose and features (pagination, sorting, limiting, payload reduction). The tool has 7 parameters, 1 required, and moderate complexity. The description feels complete for an agent to select and invoke 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 7 parameters have descriptions in the schema. The tool description adds no new parameter information beyond summarizing the purpose. It mentions three param names (projection_preset, data_fields, item_fields) but only generally. Baseline score is 3 due to 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?

The description clearly states this tool returns a paginated list of videos from a user's profile, using the specific verb 'Returns' and resource 'videos from a user's profile'. It distinguishes itself from sibling tools like tiktok_get_user_followers or tiktok_get_user_likes by focusing on videos, and from tiktok_get_video by operating on a user's full profile rather than a single 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?

The description provides clear context for when to use this tool: to get videos from a user's profile. It mentions sorting options and pagination, implying usage for browsing or fetching a set of videos. However, it doesn't explicitly state when not to use it or name alternatives, though siblings like tiktok_get_user_likes or tiktok_get_video exist.

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

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

Annotations indicate readOnlyHint=false (not read-only), destructiveHint=false (not destructive), and idempotentHint=false (not idempotent). Despite minimal annotation coverage, the description adds value by specifying the returned data categories and optimization features. It does not explicitly state behavior changes or side effects, which are unnecessary given the non-destructive, non-read-only nature.

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?

Description is two sentences, efficiently covering purpose, return data, and customization options. 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?

Tool has 3 parameters with 100% schema coverage, no output schema, and moderate complexity. The description mentions key data fields and optimization options, which is sufficient for an agent to understand the tool's use. Could be slightly more detailed about behavior.

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

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

Schema description coverage is 100%, so parameters are fully described in the schema. The description adds mention of 'data_fields' and 'projection_preset' for payload reduction, but does not provide deeper semantics 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 tool returns details for a single TikTok video, listing specific data categories (engagement counts, media files, audio, author, hashtags). This differentiates it from sibling tools like tiktok_get_audio or tiktok_get_user_videos.

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

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

The description mentions payload reduction options but does not provide explicit guidance on when to use this tool vs alternatives like tiktok_get_video_comments or tiktok_search_videos. Implied use is for a single video's complete details.

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?

Describes pagination limit (50 per page) and payload reduction features, beyond annotations which only provide readOnlyHint false and idempotentHint false. 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 covering all essential points without redundancy or extraneous details.

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

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

Provides enough information for an AI agent to understand usage and restrictions. Lacks output schema but pagination details are clear.

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

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

Schema coverage is 100% with descriptions for all parameters. Description adds context about pagination limit and payload reduction but does not significantly enhance beyond 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?

Description clearly states it returns top-level comments for a video, includes pagination and a link to the replies endpoint. Differentiates from sibling tools like tiktok_get_comment_replies.

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 mentions using the replies endpoint for threaded replies, providing a clear usage context. No explicit when-not-to-use or alternatives beyond that.

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 annotation readOnlyHint=false contradicts the implied read-only nature of the tool (returning a transcript). The description does not clarify any side effects or mutations, creating a contradiction. While it adds details about output format and payload reduction, the inconsistency with annotations undermines transparency.

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

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

The description is concise with three sentences, no fluff. It front-loads the primary action and adds key details efficiently. Every sentence adds value.

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

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

While no output schema is provided, the description mentions the return format (WebVTT). All four parameters are covered with some extra context. However, it could mention prerequisites (e.g., video must have captions) or error conditions, but given the tool's simplicity, it is largely complete.

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

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

Schema coverage is 100%, but the description adds meaningful context beyond the schema: it explains that 'original' returns the auto-generated transcript, BCP47 codes yield machine-translated subtitles, and it mentions the WebVTT format. It also describes projection_preset and data_fields as 'for payload reduction,' which is not in the schema.

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

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

The description clearly states the tool's purpose: 'Returns the transcript for a video.' It specifies the verb (returns) and resource (transcript), and distinguishes it from sibling tools like tiktok_get_video or tiktok_get_audio by focusing on transcript 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 provides clear guidance on language selection: 'Use `original` as the language to return the auto-generated transcript, or provide a BCP47 language code for machine-translated subtitles.' It does not explicitly state when not to use or suggest alternatives, but the context is clear enough for an agent.

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

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

Annotations indicate readOnlyHint=false, destructiveHint=false, and openWorldHint=true, suggesting it makes external requests. The description adds that it returns 'mixed results' and supports payload reduction, which is useful. However, it does not disclose details like rate limits, authentication needs, or that results may vary (though the schema's count description hints at actual results varying). With annotations already present, the description provides moderate additional context.

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

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

The description is three concise sentences, each adding distinct value: first states the tool's core purpose, second lists key features, third lists specific payload options. No wasted words; front-loaded with essential info.

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

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

Given the tool has 8 parameters (1 required), no output schema, and annotations, the description adequately explains the tool's behavior and parameters. It mentions sorting, filters, and payload reduction. However, it could briefly note pagination or that results are across content types (videos+users). Minor gap for a mixed-search tool.

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

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

Input schema covers all 8 parameters with descriptions (100% schema_description_coverage). The description mentions support for 'projection_preset, data_fields, and item_fields for payload reduction,' which adds context beyond the schema's individual descriptions. However, since schema already covers each parameter, the description's added value is moderate; 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 'General search that returns mixed results including videos and user profiles.' This specifies the verb (search) and resource (content, i.e., videos and user profiles). However, it does not explicitly distinguish from sibling tools like tiktok_search_videos or tiktok_search_users, though the 'mixed results' phrase implies it combines both, setting it apart.

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 mentions features like 'supports sorting and publish-time filters' and 'supports projection_preset... for payload reduction,' giving context on when to invoke optional parameters. However, it does not explicitly state when to use this tool over sibling search tools (e.g., tiktok_search_videos or tiktok_search_users), nor does it provide exclusions or 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 indicate readOnlyHint=false and idempotentHint=false, but destructiveHint=false and openWorldHint=true. The description explains fixed page size (10) and payload reduction options, which adds behavioral context. However, it does not mention that the tool performs a read operation (despite open world) or any mutation implications, which is consistent 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 three sentences: purpose, fixed page size, return profile details, and payload reduction options. It is concise and front-loaded with the main action. No wasted words, but could be more structured with bullets for parameters.

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

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

Given the complexity (6 params, no output schema), the description covers the main purpose, pagination constraint, return fields (follower counts, verification), and payload reduction. Missing details on pagination via cursor or how to use it, but the schema covers cursor. Completeness is good for a search tool with high schema coverage.

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 having a description. The description adds context that 'count' is fixed at 10 by the platform, which is not in the schema's description (which only says 'Page size (fixed at 10 by the platform)'). The description also summarizes projection_preset, data_fields, and item_fields for payload reduction, adding 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 it searches TikTok for user profiles matching a query, distinguishing it from sibling tools like tiktok_search_videos (searches videos) and tiktok_search_content (generic search). The verb 'searches' and resource 'user profiles' are specific.

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

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

The description mentions a fixed page size of 10 as a platform limit, which implies pagination limits but does not explicitly guide when to use this tool versus alternatives like tiktok_get_user (which retrieves a specific user) or other search tools. No when-not-to-use or exclusion criteria given.

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

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

Annotations already provide readOnlyHint=false (meaning writes may occur) and destructiveHint=false (not destructive). The description adds that the tool supports pagination (cursor) and payload reduction features (projection_preset, data_fields, item_fields), which are behavioral traits beyond annotations. However, it does not mention write behavior or other side effects. With annotations doing partial work, the description adds moderate 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 three sentences, each adding distinct value: first states core purpose, second adds filtering/sorting options, third mentions payload reduction features. No unnecessary words. Slightly verbose for mentioning all three payload reduction options explicitly, but still concise.

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

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

Given the complexity of 8 parameters and no output schema, the description covers key features (filters, sorting, payload reduction) but lacks details about return structure, pagination behavior, or rate limits. The context signals show high schema coverage, so the description is adequate but not fully complete for a search tool with many options.

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 every parameter already has description in the schema. The description adds high-level semantics by mentioning filtering and sorting, but does not add meaning beyond what schema provides. 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 verb 'Searches' and the resource 'videos on TikTok'. It distinguishes from siblings like tiktok_search_content and tiktok_search_users by specifying it searches videos, and the title explicitly says 'Search videos'. The description also adds specific features like filtering and sorting, which sets clear expectations.

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

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

The description implies usage for searching videos, but does not explicitly state when to use this tool versus alternatives like tiktok_search_content (which might search broader content). No exclusions or when-not-to-use guidance is provided. The description is adequate but lacks comparative context.

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

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

The description claims the tool 'returns' data, implying a read-only operation, but annotations set readOnlyHint=false, suggesting possible side effects. This contradiction undermines transparency. The description does not disclose any behavioral traits beyond what is stated, and the annotation contradiction is critical.

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

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

The description is two sentences, front-loaded with the core purpose, and uses the second sentence to add parameter context. No filler or redundant information.

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

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

Given no output schema, the description lists included data elements but omits error behavior (e.g., if post is deleted), rate limits, or authentication needs. The openWorldHint annotation suggests incompleteness, but the description does not address this. It is adequate but has 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?

With 100% schema coverage, the description adds value by explaining that projection_preset and data_fields are for 'payload reduction,' clarifying their purpose. This goes beyond the schema's enum lists and helps the agent reduce response size.

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 a public X post, listing specific content like text, author, engagement counts, and media attachments. It distinguishes itself from sibling tools like x_get_user_posts by focusing on a single post, and the name 'x_get_post' reinforces this.

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

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

The description implies usage when needing a single post's data, but provides no explicit guidance on when to use this tool versus alternatives like x_get_user_posts or other platform tools. 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?

The description indicates a read operation ('Returns profile information'), but the annotation readOnlyHint is false, which contradicts the behavior. No authentication, rate limit, or other behavioral details are provided, leaving a significant gap.

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

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

Two concise sentences front-load the main purpose and then mention parameter supports. 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?

Without an output schema, the description lists key return fields (bio, follower counts, etc.) and explains parameter usage. It is sufficient for a simple get user profile, though it could mention authentication or privacy constraints beyond 'public'.

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 covers all parameters with descriptions (100% coverage). The description adds value by explaining that projection_preset and data_fields support payload reduction, going beyond the schema's explanation.

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