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

No annotations are provided, so the description carries the full burden of behavioral disclosure. It states the action is a deletion, implying a destructive mutation, but doesn't cover critical aspects like authentication requirements, irreversibility, rate limits, error conditions (e.g., if the tweet doesn't exist), or what happens upon success. For a destructive tool with zero annotation coverage, this is 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?

The description is a single, direct sentence with zero waste—it states the action, resource, and key input concisely. It's appropriately sized and front-loaded, making it easy for an agent to parse quickly.

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 (a destructive mutation with no annotations and no output schema), the description is incomplete. It lacks information on behavioral traits, usage context, and expected outcomes. While the schema covers the parameter well, the overall context for safe and effective use is insufficient.

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

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

Schema description coverage is 100%, with the parameter 'tweet_id' fully documented in the schema as 'The tweet ID or URL to delete'. The description adds no additional meaning beyond this, such as format examples or constraints. Baseline 3 is appropriate when 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 action ('Delete') and the resource ('a post on X by its ID'), making the purpose unambiguous. However, it doesn't differentiate this tool from potential alternatives like 'unlike' or 'unretweet' operations, which might be relevant in a Twitter/X context but aren't present in the sibling list, so it misses the highest score.

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

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

The description provides no guidance on when to use this tool versus alternatives. It doesn't mention prerequisites (e.g., needing to own the tweet), exclusions (e.g., cannot delete others' tweets), or related tools like 'post_tweet' for creation. This leaves the agent with minimal context for decision-making.

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

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

With no annotations provided, the description carries the full burden of behavioral disclosure. It mentions listing followers but does not cover critical aspects like pagination behavior (implied by 'next_token' in schema but not explained), rate limits, authentication needs, or error handling. This leaves significant gaps in understanding how the tool operates beyond basic functionality.

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

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

The description is a single, direct sentence that efficiently conveys the core action without unnecessary words. It is front-loaded with the main purpose, making it easy to parse quickly, and every part of the sentence contributes to understanding the tool's function.

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

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

Given the complexity of a tool with 3 parameters, no annotations, and no output schema, the description is insufficient. It lacks details on return values (e.g., format of follower data), error cases, or behavioral traits like pagination. For a data retrieval tool in a social media context, more context is needed to ensure proper usage by an AI 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?

The schema description coverage is 100%, with clear descriptions for all parameters (user_id, max_results, next_token). The description adds minimal value by mentioning 'numeric user ID', which is already covered in the schema. Since the schema does the heavy lifting, the baseline score of 3 is appropriate, as the description does not significantly enhance parameter understanding.

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

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

The description clearly states the verb ('List') and resource ('followers of a user'), making the purpose specific and understandable. However, it does not explicitly differentiate from sibling tools like 'get_following' or 'get_user', which might also involve user-related data retrieval, leaving room for ambiguity in tool selection.

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

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

The description provides no guidance on when to use this tool versus alternatives, such as 'get_following' (which might list users followed by a user) or 'get_user' (which might retrieve user details). It lacks context on prerequisites, exclusions, or comparisons with siblings, offering minimal usage direction.

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

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

No annotations are provided, so the description carries full burden. It mentions listing by user ID but doesn't disclose behavioral traits like pagination handling (implied by next_token), rate limits, authentication needs, error conditions, or return format. For a read operation with pagination, this is a significant gap in 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 a single, efficient sentence that front-loads the core purpose without unnecessary words. It's appropriately sized for a straightforward tool, with zero waste or redundancy.

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

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

Given no annotations, no output schema, and a read operation with pagination (implied by next_token), the description is incomplete. It doesn't explain what the output contains (e.g., list of users, pagination tokens), error handling, or constraints like rate limits. For a tool in a social media context with siblings, more context 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 description coverage is 100%, so the schema fully documents parameters (user_id, max_results, next_token). The description adds minimal value beyond the schema by specifying 'numeric user ID' for user_id, but doesn't explain parameter interactions or usage nuances. 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 action ('List') and resource ('who a user follows'), specifying it's by user ID. It distinguishes from siblings like get_followers (who follows the user) and get_user (user details), though not explicitly. However, it lacks explicit sibling differentiation, keeping it at 4 rather than 5.

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

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

The description provides no guidance on when to use this tool versus alternatives like get_followers or get_user. It states the basic function but doesn't mention context, prerequisites, or exclusions, leaving the agent to infer usage from tool names alone.

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

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

No annotations are provided, so the description carries the full burden of behavioral disclosure. It mentions fetching 'recent mentions' but doesn't specify time ranges, sorting order, or what constitutes a 'mention' (e.g., replies, tags). It also omits details on rate limits, error handling, or response format, leaving significant gaps for a tool with potential complexity.

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

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

The description is a single, efficient sentence that directly states the tool's purpose without unnecessary words. It is front-loaded and wastes no space, making it easy to parse quickly.

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

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

Given the lack of annotations and output schema, the description is incomplete. It doesn't explain what the return values look like (e.g., list structure, fields included) or address behavioral aspects like pagination beyond the 'next_token' parameter hint. For a tool fetching social media data, more context on output and constraints 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?

The input schema has 100% description coverage, clearly documenting both parameters ('max_results' and 'next_token') with their types and constraints. The description adds no additional parameter semantics beyond what the schema provides, which is acceptable given the high schema coverage, resulting in a baseline score.

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

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

The description clearly states the action ('Fetch') and target resource ('recent mentions of the authenticated user'), making the purpose immediately understandable. However, it doesn't explicitly differentiate from sibling tools like 'search_tweets' or 'get_timeline' that might also retrieve mentions in different contexts, preventing a perfect score.

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

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

The description provides no guidance on when to use this tool versus alternatives like 'search_tweets' or 'get_timeline', nor does it mention prerequisites such as authentication requirements. It simply states what it does without contextual usage instructions.

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

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

With no annotations provided, the description carries full burden. It discloses key behavioral traits: it requires the tweet to be authored by the authenticated user for non-public metrics, which is crucial for permission/access context. However, it lacks details on rate limits, error handling, or response format.

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

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

Two sentences, front-loaded with the core purpose and followed by an important constraint. Every sentence earns its place with no wasted words, making it efficient and easy to parse.

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

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

Given no annotations and no output schema, the description is moderately complete. It covers purpose and a key constraint, but lacks details on return values (e.g., metric types, units) or other behavioral aspects like pagination or errors, which are important for a metrics 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 description coverage is 100%, so the schema already documents the tweet_id parameter. The description does not add meaning beyond what the schema provides (e.g., format examples or constraints), but it implies the parameter is used to identify the post for metrics retrieval.

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

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

The description clearly states the verb 'Get' and the resource 'engagement metrics for a specific post', with explicit examples (impressions, likes, retweets, replies, quotes, bookmarks). It distinguishes from siblings like get_tweet (general tweet data) or search_tweets (multiple tweets) by focusing on metrics for a single 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 provides clear context on when to use it: for engagement metrics of a specific post. It implies usage for the authenticated user's tweets for non-public metrics, but does not explicitly state when NOT to use it or name alternatives (e.g., get_tweet for basic data).

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

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

No annotations are provided, so the description carries the full burden. It discloses the requirement for a numeric user ID and implies a read-only operation ('Fetch'), but lacks details on rate limits, authentication needs, error handling, or what 'recent' means temporally. It adds some context (the ID resolution step) but misses key behavioral traits for a tool with no 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 core purpose and followed by a crucial prerequisite. Every word earns its place—no redundancy or fluff—making it highly efficient and easy to parse for an agent.

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

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

Given no annotations and no output schema, the description is incomplete for a tool with 3 parameters and behavioral complexity. It covers the basic purpose and ID requirement but omits details on return values, error cases, or operational constraints (e.g., rate limits). For a read operation with pagination, more context would be needed to achieve a higher score.

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 (user_id, max_results, next_token) thoroughly. The description adds marginal value by emphasizing the need for a numeric ID and hinting at pagination ('previous response'), but does not provide additional syntax or format details beyond what the schema specifies. Baseline 3 is appropriate here.

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 specific action ('Fetch') and resource ('user's recent posts'), distinguishing it from siblings like get_tweet (single tweet) or search_tweets (keyword-based). It specifies the scope as 'recent posts' for a particular user, making the purpose unambiguous and differentiated.

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

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

The description provides clear context on when to use it: for fetching a user's posts, with a prerequisite to 'use get_user first to resolve username to ID'. However, it does not explicitly state when not to use it or name alternatives (e.g., get_mentions for mentions or search_tweets for broader queries), which prevents a perfect score.

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

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

With no annotations provided, the description carries the full burden of behavioral disclosure. It mentions the return content ('author info, metrics, and referenced tweets'), which is helpful, but omits critical details like rate limits, authentication requirements, error conditions, or whether it's a read-only operation. For a tool with zero annotation coverage, this leaves significant gaps.

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

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

The description is a single, efficient sentence that front-loads the core purpose and includes key details without waste. Every part earns its place by clarifying input, output, and scope.

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 moderate complexity (single parameter, no output schema, no annotations), the description is adequate but incomplete. It covers purpose and output types but lacks behavioral context like safety or performance traits, which is a notable gap for a tool with zero annotation support.

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 the tweet_id parameter fully. The description adds marginal value by noting it accepts 'ID or URL,' but this is implied in the schema's description. 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 specific action ('Fetch') and resource ('a tweet and its metadata'), distinguishes it from siblings by focusing on individual tweet retrieval rather than timelines, searches, or user-related operations, and specifies the input method ('by ID or URL').

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

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

The description implies usage context by specifying 'by ID or URL,' which differentiates it from tools like search_tweets or get_timeline that handle multiple tweets. However, it lacks explicit when-not-to-use guidance or named alternatives for similar operations.

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

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

No annotations are provided, so the description carries the full burden. It mentions the return fields ('bio, metrics, verification status, etc.') but lacks critical behavioral details: authentication requirements, rate limits, error handling (e.g., for invalid inputs), or whether it's read-only (implied but not stated). For a lookup tool with zero annotation coverage, this is inadequate.

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 appropriately sized and front-loaded: two concise sentences that directly state the action and returns. Every sentence earns its place 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?

Given the complexity (a lookup tool with 2 parameters) and lack of annotations/output schema, the description is incomplete. It omits authentication needs, error cases, and detailed return structure (beyond a vague list). For a tool in a social media context with siblings like delete_tweet, more context on safety and usage is warranted.

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 both parameters (username and user_id). The description adds minimal value by restating 'by username or user ID' without clarifying exclusivity, precedence, or format beyond the schema. Baseline 3 is appropriate when 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's purpose: 'Look up a user profile by username or user ID' (specific verb+resource). It distinguishes from siblings like get_followers or get_timeline by focusing on user profiles rather than social interactions or content. However, it doesn't explicitly differentiate from get_metrics (which might overlap with 'metrics' in returns).

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

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

The description provides no guidance on when to use this tool versus alternatives. It doesn't mention prerequisites (e.g., authentication), exclusions, or comparisons to siblings like get_metrics (which might handle similar data). The context is implied but not explicit.

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

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

With no annotations provided, the description carries the full burden of behavioral disclosure. It states the action ('like') but doesn't describe what this entails (e.g., is it reversible, does it require specific permissions, are there rate limits, what happens on success/failure). For a mutation tool, this leaves significant gaps.

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

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

The description is extremely concise with a single sentence ('Like a post on X.'), front-loading the core action. There is no wasted language, making it efficient and easy to parse.

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

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

Given the complexity of a mutation tool (liking a tweet) with no annotations and no output schema, the description is incomplete. It lacks details on behavioral aspects (e.g., effects, error handling) and doesn't compensate for the missing structured data, leaving the agent with insufficient 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 description coverage is 100%, with the parameter 'tweet_id' fully documented in the schema. The description adds no additional parameter semantics beyond what the schema provides, so it meets the baseline score of 3 for 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 'Like a post on X' clearly states the action (like) and resource (post on X), making the purpose immediately understandable. However, it doesn't distinguish this tool from sibling tools like 'retweet' or 'reply_to_tweet' beyond the basic action, missing explicit differentiation.

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

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

The description provides no guidance on when to use this tool versus alternatives. It doesn't mention prerequisites (e.g., authentication, tweet visibility), exclusions (e.g., cannot like own tweets), or comparisons to similar tools like 'retweet' or 'reply_to_tweet'.

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

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

With no annotations provided, the description carries the full burden of behavioral disclosure. It mentions the action ('Create') and supported features, but fails to disclose critical traits: it doesn't state that this is a write operation (implied but not explicit), mention authentication requirements, rate limits, or what happens on success/failure. For a mutation tool with zero annotation coverage, this is 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?

The description is a single, efficient sentence that front-loads the core purpose and lists key features without waste. Every word earns its place, making it easy to parse quickly.

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 a write operation (posting to X/Twitter) with no annotations and no output schema, the description is incomplete. It lacks essential context: authentication needs, error handling, rate limits, and response format. For a tool with 4 parameters and mutation behavior, this leaves the agent under-informed.

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

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

Schema description coverage is 100%, so the schema fully documents all parameters. The description adds minimal value beyond the schema by listing supported content types ('text, polls, and media attachments'), which loosely maps to parameters but doesn't provide additional syntax or format details. This meets the baseline for 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 ('Create') and resource ('new post on X (Twitter)'), and specifies supported content types ('text, polls, and media attachments'). It distinguishes from siblings like 'delete_tweet' or 'reply_to_tweet' by focusing on creation, though it doesn't explicitly contrast with similar tools like 'quote_tweet' or 'retweet'.

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

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

The description provides no guidance on when to use this tool versus alternatives. It doesn't mention prerequisites (e.g., authentication), when to choose this over 'reply_to_tweet' or 'quote_tweet', or any constraints like rate limits. This leaves the agent with minimal context for decision-making.

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

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

No annotations are provided, so the description carries the full burden of behavioral disclosure. While it states the tool performs a quote retweet with commentary, it doesn't mention authentication requirements, rate limits, whether the action is reversible (e.g., via 'delete_tweet'), potential side effects, or what the response looks like. For a mutation tool with zero annotation coverage, this is a significant gap in 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 a single, efficient sentence that front-loads the core action ('quote retweet a post on X') and adds essential detail ('adds your commentary above the quoted post'). There is zero waste, and every word earns its place by clarifying the tool's purpose.

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

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

Given this is a mutation tool with no annotations and no output schema, the description is incomplete. It lacks information about authentication, error handling, return values, and behavioral constraints. While the purpose is clear, the description doesn't provide enough context for safe and effective use by an AI agent without additional assumptions.

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

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

Schema description coverage is 100%, so the schema already documents all three parameters (tweet_id, text, media_ids) with clear descriptions. The description adds no additional meaning beyond what the schema provides, such as formatting examples or constraints on the commentary text. Baseline 3 is appropriate when 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 specific action ('quote retweet'), the resource ('a post on X'), and the exact functionality ('adds your commentary above the quoted post'). It distinguishes this tool from siblings like 'retweet' (which doesn't add commentary) and 'reply_to_tweet' (which creates a reply thread rather than a quote retweet).

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 you want to share a tweet with your own commentary, but it doesn't explicitly state when to use this tool versus alternatives like 'retweet' or 'reply_to_tweet'. No guidance is provided about prerequisites, limitations, or when not to use this tool, leaving the agent to infer context from the action described.

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

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

With no annotations provided, the description carries full burden but lacks behavioral details. It doesn't disclose permissions needed, rate limits, whether replies are editable/deletable, character limits, or response format. 'Reply to' implies mutation but offers no safety or operational 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 a single, efficient sentence with zero wasted words. It front-loads the core action and key parameters, making it easy to parse quickly.

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

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

For a mutation tool with no annotations and no output schema, the description is incomplete. It lacks critical context: authentication requirements, error conditions, return values, and how it differs from sibling tools like 'quote_tweet'. The 100% schema coverage helps but doesn't compensate for missing behavioral transparency.

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

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

Schema description coverage is 100%, so parameters are fully documented in the schema. The description adds no additional meaning beyond implying 'tweet_id' and 'text' are required (matching schema), but doesn't explain parameter interactions or constraints like media attachment limits.

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

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

The description clearly states the action ('Reply to') and target resource ('an existing post on X'), distinguishing it from siblings like 'post_tweet' or 'quote_tweet'. However, it doesn't explicitly differentiate from 'reply_to_tweet' (itself) or mention alternatives like 'quote_tweet' for different reply types.

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

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

The description provides no guidance on when to use this tool versus alternatives like 'quote_tweet' or 'post_tweet', nor does it mention prerequisites (e.g., authentication, tweet visibility). It only states the basic action 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?

With no annotations provided, the description carries the full burden of behavioral disclosure. It states the action ('retweet') but doesn't describe key traits such as whether this is a mutation (implied but not explicit), authentication requirements, rate limits, or what happens on success/failure. For a tool that likely modifies data, this is a significant gap in 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 a single, clear sentence with zero waste—it directly states the tool's purpose without unnecessary words. It's appropriately sized for a simple tool and front-loaded with essential information, making it highly efficient.

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

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

Given the tool's complexity (a mutation with no annotations and no output schema), the description is incomplete. It lacks details on behavioral traits, usage context, and expected outcomes. For a tool that performs an action like retweeting, more information is needed to guide the agent 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?

The input schema has 100% description coverage, with the single parameter 'tweet_id' documented as 'The tweet ID or URL to retweet'. The description adds no additional meaning beyond this, such as format examples or constraints. Since the schema does the heavy lifting, the baseline score of 3 is appropriate.

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

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

The description clearly states the action ('retweet') and the resource ('a post on X'), making the purpose immediately understandable. It distinguishes itself from siblings like 'like_tweet', 'quote_tweet', and 'reply_to_tweet' by specifying the retweet action. However, it doesn't explicitly differentiate from all siblings (e.g., 'post_tweet' could be ambiguous), keeping it from a perfect score.

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

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

The description provides no guidance on when to use this tool versus alternatives. It doesn't mention prerequisites (e.g., authentication, permissions), exclusions (e.g., when retweeting is not allowed), or comparisons to siblings like 'quote_tweet' or 'like_tweet'. This lack of context leaves the agent without usage direction.

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

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

With no annotations provided, the description carries full burden. It discloses key behavioral traits: the temporal constraint ('last 7 days'), endpoint type ('recent search endpoint'), and query syntax support. However, it doesn't mention rate limits, authentication requirements, or what the response format looks like, leaving gaps for a search tool.

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

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

The description is extremely concise with just two sentences that each earn their place: the first states purpose and capabilities, the second adds critical behavioral context about temporal scope. No wasted words, perfectly 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 search tool with 3 parameters, 100% schema coverage, but no annotations and no output schema, the description provides adequate purpose and behavioral context but lacks information about response format, error conditions, or authentication requirements that would be helpful for an AI agent.

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

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

Schema description coverage is 100%, so the schema already fully documents all 3 parameters. The description adds minimal value beyond the schema by mentioning query syntax examples ('keywords, hashtags, from:user, etc.') but doesn't provide additional semantic context about parameters beyond what's in 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 the specific action ('Search recent tweets by query') and resource ('tweets'), distinguishing it from siblings like get_timeline or get_mentions by specifying it's a search operation. It explicitly mentions the 'recent search endpoint' which further clarifies scope.

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 about when to use this tool ('Search recent tweets by query') and mentions the temporal limitation ('last 7 days'), but doesn't explicitly state when NOT to use it or name specific alternatives among siblings like get_timeline or get_mentions for 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?

With no annotations, the description carries full burden but provides minimal behavioral context. It mentions the return value (media_id) but lacks details on error conditions, rate limits, authentication requirements, or side effects (e.g., whether uploads are public or private).

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

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

Two concise sentences with zero waste: the first states purpose and outcome, the second provides key parameter guidance. It's front-loaded and appropriately sized for the tool's complexity.

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

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

For a mutation tool with no annotations and no output schema, the description is adequate but incomplete. It covers the basic purpose and parameter format but lacks critical context like error handling, usage constraints, or integration with sibling tools (e.g., post_tweet).

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

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

Schema description coverage is 100%, so the schema fully documents parameters. The description adds marginal value by clarifying that media_data is 'base64-encoded' and that the media_id is for attaching to posts, but doesn't provide additional semantics beyond what the schema already covers.

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 specific action ('upload'), resource ('image or video to X'), and outcome ('returns a media_id that can be attached to posts'), distinguishing it from sibling tools that focus on reading, deleting, or interacting with tweets rather than uploading 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?

No guidance is provided on when to use this tool versus alternatives. It doesn't mention prerequisites (e.g., authentication), constraints (e.g., file size limits), or how it relates to sibling tools like post_tweet (which might use the media_id).

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