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

With no annotations provided, the description carries full burden for behavioral disclosure. It mentions the tool returns 'bio, follower count, media count, etc.' which gives some output context, but doesn't address important behavioral aspects like rate limits, authentication requirements, error conditions, or whether this is a read-only operation (though implied by 'look up'). For a tool with zero annotation coverage, this is insufficient.

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

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

The description is appropriately concise with two sentences: one stating the purpose and scope, another describing the return values. It's front-loaded with the core functionality. It could be slightly more structured by explicitly separating purpose from output description.

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

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

Given the tool has no annotations, no output schema, and a simple single parameter, the description provides basic completeness by stating purpose and sample return values. However, for a profile lookup tool in a social media context, it should ideally mention authentication requirements, rate limits, or data freshness considerations to be fully complete.

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

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

Schema description coverage is 100%, so the schema already fully documents the single parameter. The description doesn't add any parameter-specific information beyond what's in the schema (which specifies 'Instagram username to look up (without @)'). This meets the baseline of 3 when 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 another public Business or Creator account's profile' with specific verb ('look up') and resource ('profile'), and distinguishes it from siblings by specifying it's for public accounts only. It loses a point because it doesn't explicitly differentiate from 'get_profile_info' which might be for the user's own profile.

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

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

The description implies usage context by specifying 'public Business or Creator account's profile', suggesting it's for external accounts rather than the authenticated user's own profile. However, it doesn't provide explicit guidance on when to use this versus 'get_profile_info' or other profile-related tools, nor does it mention any 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?

With no annotations provided, the description carries the full burden. It discloses that the tool is destructive (deletion) and has an ownership constraint ('your own media'), which are key behavioral traits. However, it lacks details on permissions, error handling, or response format, leaving gaps 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 front-loaded and concise with two sentences that directly convey purpose and constraints. Every word earns its place, with no redundant or vague language, 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 (destructive action with ownership constraints), no annotations, and no output schema, the description is adequate but incomplete. It covers the core action and limitation but misses details like return values or error cases, which are important for such a 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?

The input schema has 100% description coverage, with 'comment_id' clearly documented. The description does not add any parameter-specific details beyond the schema, so it meets the baseline of 3 for high schema coverage without extra value.

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 ('Delete a comment') and resource ('on your Instagram post'), and distinguishes it from siblings like 'hide_comment' or 'post_comment' by specifying deletion. It is precise and avoids tautology.

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

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

It provides clear context on when to use this tool ('Can only delete comments on your own media'), which implicitly guides usage. However, it does not explicitly mention when not to use it or name alternatives like 'hide_comment' for non-deletion actions, so it falls short of 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 states the tool retrieves insights and analytics, implying a read-only operation, but doesn't cover aspects like authentication requirements, rate limits, data freshness, or error conditions. This leaves significant gaps for an agent to understand how to use it effectively.

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'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?

For a tool with no annotations and no output schema, the description is incomplete. It doesn't explain what the insights include (e.g., numerical data, trends), how results are formatted, or any limitations (e.g., data availability periods). Given the complexity of analytics tools, more context is needed for an agent to use it correctly.

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

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

The description adds no parameter-specific information beyond what's already in the input schema, which has 100% coverage with clear descriptions and enums. The baseline score of 3 reflects that the schema adequately documents the parameters, so the description doesn't need to compensate but also doesn't add extra value.

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

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

The description clearly states the action ('Get') and resource ('account-level insights and analytics for Instagram business account'), making the purpose understandable. However, it doesn't differentiate this tool from sibling tools like 'get_media_insights' or 'get_profile_info', which also retrieve Instagram data but for 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 provides no guidance on when to use this tool versus alternatives. It doesn't mention prerequisites (e.g., needing a business account), exclusions, or compare it to siblings like 'get_media_insights' for post-level data or 'business_discovery' for competitor insights.

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 states what data is retrieved but lacks critical details: whether this is a read-only operation, if it requires specific permissions, rate limits, pagination behavior, or error conditions. For a data retrieval tool with zero annotation coverage, this leaves significant gaps in understanding its behavior.

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

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

The description is a single, efficient sentence that front-loads the core purpose without unnecessary words. It directly states what the tool does ('Get Facebook pages... and their Instagram business accounts'), earning its place by clearly defining scope. There is no redundancy or fluff.

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

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

Given the complexity (retrieving connected social media accounts), lack of annotations, and no output schema, the description is incomplete. It doesn't explain what the output includes (e.g., page IDs, names, Instagram account details), potential errors, or dependencies like authentication. For a tool in a server with many siblings, more context is needed to 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?

The tool has 0 parameters, and schema description coverage is 100% (since there are no parameters to describe). The description doesn't need to add parameter semantics, but it correctly implies no inputs are required. Baseline for 0 parameters is 4, as the description aligns with the empty 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: retrieving Facebook pages and their connected Instagram business accounts. It uses specific verbs ('Get') and resources ('Facebook pages', 'Instagram business accounts'), making the function unambiguous. However, it doesn't explicitly differentiate from sibling tools like 'get_profile_info' or 'business_discovery', which might also retrieve account-related data.

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

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

The description provides no guidance on when to use this tool versus alternatives. It doesn't mention prerequisites (e.g., authentication state), exclusions, or compare it to siblings like 'get_profile_info' for general account data or 'business_discovery' for business-specific insights. Usage is implied only by the tool's name and description.

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

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

No annotations are provided, so the description carries the full burden of behavioral disclosure. It states the tool returns comment data (text, username, timestamp, like count), which is useful. However, it lacks critical details like whether this is a read-only operation, potential rate limits, authentication requirements, error handling, or pagination behavior for large comment sets. The description is insufficient for a tool with no annotation support.

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 key return values. Every word earns its place with no redundancy or fluff, 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 no annotations and no output schema, the description is minimally adequate but has clear gaps. It covers the basic purpose and return fields, which helps, but lacks behavioral context (e.g., safety, performance) and detailed usage guidance. For a simple read tool with full schema coverage, it meets the minimum viable threshold but doesn't fully compensate for missing structured data.

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 (media_id and limit with constraints). The description adds no additional parameter semantics beyond what the schema provides, such as format examples for media_id or context for the limit default. Baseline score of 3 is appropriate since 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 verb 'Get' and resource 'comments on an Instagram post', specifying what the tool does. It distinguishes from siblings like 'delete_comment' or 'post_comment' by focusing on retrieval. However, it doesn't explicitly differentiate from similar tools like 'get_mentions' or 'get_conversation_messages' beyond the Instagram post context.

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), compare to siblings like 'get_mentions' for comment retrieval in different contexts, or specify scenarios where this tool is preferred. Usage is implied by the action but not explicitly defined.

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 Instagram's 24-hour limit, which is useful context, but it does not describe the return format (e.g., numeric count, percentage), error conditions, or authentication requirements, leaving significant gaps for a tool that likely involves rate-limiting checks.

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

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

The description is two sentences with zero waste: the first sentence states the purpose, and the second provides essential context about Instagram's limits. It is front-loaded and appropriately sized for a simple tool.

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

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

Given the tool's complexity (simple query with 0 parameters) and lack of annotations and output schema, the description is minimally complete. It explains what the tool does and the platform constraint, but without annotations or output schema, it should ideally describe the return value or behavior more explicitly to fully guide 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?

The tool has 0 parameters, and schema description coverage is 100%, so there is no need for parameter details in the description. The description appropriately avoids discussing parameters, earning a baseline score of 4 for not adding unnecessary information.

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

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

The description clearly states the tool's purpose with a specific verb ('Check') and resource ('how many posts you can still publish today'), and it distinguishes itself from siblings by focusing on publishing limits rather than content retrieval, posting, or account management operations.

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 ('today' and 'per 24-hour period'), but it does not explicitly state when not to use it or name alternatives among the sibling tools (e.g., it doesn't contrast with publishing tools like publish_media).

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 a permission requirement, which is useful context. However, it lacks details on rate limits, pagination, error handling, or what the output looks like (e.g., message format, ordering), leaving gaps in behavioral 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?

The description is a single, efficient sentence with zero waste. It front-loads the core purpose and includes essential permission information, making it appropriately sized and well-structured 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?

Given no annotations and no output schema, the description is incomplete for a tool that retrieves data. It covers the basic action and permission but omits details on return values (e.g., message structure), error conditions, or limitations beyond the schema. This is adequate but has clear gaps for an agent to 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 description coverage is 100%, so the schema fully documents both parameters. The description doesn't add any meaning beyond the schema, such as explaining how 'conversation_id' is obtained or typical use cases for 'limit'. Baseline 3 is appropriate when the schema handles parameter documentation.

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

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

The description clearly states the action ('Get messages') and resource ('from a specific Instagram DM conversation'), making the purpose evident. However, it doesn't explicitly differentiate from sibling tools like 'get_conversations' (which likely lists conversations rather than messages) or 'send_dm' (which sends messages), missing full sibling distinction.

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

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

The description includes a prerequisite ('Requires instagram_manage_messages permission'), which provides some context for when to use it. However, it doesn't specify when to choose this tool over alternatives like 'get_conversations' or 'get_mentions', leaving usage implied rather than explicit.

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

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

With no annotations provided, the description carries the full burden of behavioral disclosure. It mentions a permission requirement, which is useful context. However, it lacks details on rate limits, pagination, error handling, or what the return format looks like (e.g., list of conversations with metadata). This leaves gaps in understanding how the tool behaves beyond its basic function.

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

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

The description is two short sentences with zero waste: the first states the purpose, and the second adds a critical prerequisite. It's front-loaded and efficiently conveys essential information without unnecessary elaboration.

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 (a read operation with parameters), no annotations, and no output schema, the description is partially complete. It covers the purpose and a key permission requirement but misses details on behavior (e.g., output structure, error cases) and doesn't leverage the lack of annotations to fully compensate. It's adequate but has clear gaps.

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

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

The schema description coverage is 100%, so the input schema already fully documents the two parameters (page_id and limit). The description adds no additional parameter semantics beyond what's in the schema, such as explaining how auto-detection works for page_id or typical use cases for limit. 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 ('Get') and resource ('Instagram DM conversations'), making the purpose unambiguous. It doesn't explicitly differentiate from sibling tools like 'get_conversation_messages' or 'send_dm', but the focus on conversations rather than individual messages or sending is reasonably distinct.

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

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

The description provides a prerequisite ('Requires instagram_manage_messages permission'), which gives some context for when to use it. However, it doesn't offer guidance on when to choose this tool over alternatives like 'get_conversation_messages' or 'send_dm', leaving usage somewhat implied rather than explicit.

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

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

No annotations are provided, so the description carries the full burden of behavioral disclosure. It mentions the action ('Get top or recent media') but lacks details on permissions, rate limits, response format, or potential side effects. For a tool with no annotations, this leaves significant gaps in understanding its 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 two sentences with zero waste: the first states the purpose, and the second provides a crucial usage guideline. It is appropriately sized and front-loaded, 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 incomplete for a tool that fetches media data. It covers the basic purpose and a prerequisite but lacks details on return values, error handling, or behavioral traits. However, the concise structure and clear purpose make it minimally adequate in 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 description coverage is 100%, so the schema fully documents all parameters. The description adds minimal value beyond the schema by implying the hashtag_id is obtained from 'search_hashtag,' but does not provide additional semantics for parameters like media_type or limit. 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 ('Get') and resource ('top or recent media for a hashtag'), making the purpose specific and understandable. However, it does not explicitly distinguish this tool from siblings like 'search_hashtag' or 'get_media_posts' beyond the prerequisite note, which slightly limits 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 clear context by specifying to 'use search_hashtag first to get the hashtag ID,' which acts as a prerequisite and implies an alternative tool for initial lookup. It does not, however, explicitly state when to use this tool versus other media-fetching siblings like 'get_media_posts' or 'get_mentions,' missing full alternative guidance.

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

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

With no annotations provided, the description carries the full burden of behavioral disclosure. It mentions 'detailed insights and analytics,' which implies a read-only operation, but doesn't specify authentication needs, rate limits, error conditions, or what the output format might be. This leaves significant gaps for a tool that likely interacts with an external API.

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 any fluff or redundancy. 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 complexity of an analytics tool with no annotations and no output schema, the description is insufficient. It doesn't cover behavioral aspects like authentication, rate limits, or error handling, nor does it hint at the structure of the returned insights. For a tool that likely fetches data from a platform like Instagram, 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?

The input schema has 100% description coverage, clearly documenting both parameters. The description adds no additional meaning beyond what the schema provides, such as explaining the 'media_id' format or clarifying 'metrics' usage. 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 ('Get detailed insights and analytics') and target resource ('for a specific Instagram post'), which is specific and unambiguous. However, it doesn't differentiate from sibling tools like 'get_account_insights' or 'get_media_posts', which could cover similar ground, so it doesn't reach 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, such as 'get_account_insights' for broader analytics or 'get_media_posts' for general post data. It lacks explicit context, prerequisites, or exclusions, leaving the agent to infer usage from the tool name alone.

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

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

With no annotations provided, the description carries the full burden of behavioral disclosure. It mentions 'recent media posts' and 'engagement metrics,' but doesn't specify what 'recent' means (time window), what types of posts are included (e.g., images, videos, reels), or the format of engagement metrics (e.g., likes, comments, shares). It also omits critical details like rate limits, authentication requirements, or pagination behavior beyond the 'after' parameter 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?

The description is a single, efficient sentence that front-loads the core purpose. Every word earns its place: 'Get' (action), 'recent media posts' (resource), 'from Instagram account' (context), 'with engagement metrics' (key feature). There's no redundancy or fluff.

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

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

Given the complexity of retrieving social media data with no annotations and no output schema, the description is incomplete. It lacks details on authentication needs, rate limits, error conditions, the structure of returned posts, or what 'engagement metrics' include. For a tool that likely interacts with an external API and returns rich data, this minimal description leaves significant gaps for an agent to operate 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, providing clear documentation for all three parameters. The description adds no additional parameter semantics beyond what's in the schema (e.g., it doesn't clarify if 'account_id' defaults to the authenticated user's account). With high schema coverage, the baseline score of 3 is appropriate, as the description doesn't compensate but also doesn't detract.

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: 'Get recent media posts from Instagram account with engagement metrics.' It specifies the verb ('Get'), resource ('media posts'), and includes the valuable detail about engagement metrics. However, it doesn't explicitly differentiate from sibling tools like 'get_hashtag_media' or 'get_stories' that also retrieve media content.

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 an authenticated business account), nor does it compare to sibling tools like 'business_discovery' or 'get_hashtag_media' that might retrieve similar data. The agent must infer usage from the tool name and schema 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 the tool is 'useful for tracking UGC,' which hints at a read-only, monitoring purpose, but fails to specify critical behaviors like whether it requires authentication, rate limits, pagination, or the format of returned posts. This is inadequate for a tool with no annotation support.

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 highly concise and front-loaded: two sentences that directly state the purpose and a brief use case. Every word earns its place without redundancy or fluff, 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 (fetching mentions, likely from a social media API), lack of annotations, and no output schema, the description is incomplete. It doesn't cover authentication needs, rate limits, error handling, or the structure of returned posts. While concise, it fails to provide enough context for reliable agent use, especially compared to siblings with similar data retrieval functions.

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 'limit' parameter fully documented (type, range, default). The description adds no parameter-specific information beyond what the schema provides, such as how 'limit' affects results or any implicit defaults. Given the high schema coverage, the baseline score of 3 is appropriate, as the description doesn't compensate but doesn't detract either.

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: 'Get posts where your account has been tagged or @mentioned.' It specifies the verb ('Get') and resource ('posts'), and distinguishes itself from siblings like 'get_comments' or 'get_media_posts' by focusing on mentions. However, it doesn't explicitly differentiate from 'get_conversations' or 'get_comments' in terms of mention-specific filtering, which prevents 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 implied usage guidance with 'Useful for tracking UGC,' suggesting it's for monitoring user-generated content mentions. However, it lacks explicit when-to-use rules, alternatives (e.g., vs. 'get_comments' for general comments), or exclusions. This leaves gaps in distinguishing it from similar tools, resulting in a minimal viable 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?

No annotations are provided, so the description carries the full burden of behavioral disclosure. It states this is a 'Get' operation, implying read-only behavior, but doesn't clarify permissions required, rate limits, error conditions, or what happens if no account_id is provided (beyond the schema's note). For a tool with zero annotation coverage, this lacks critical context about safety and operational 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 a single, efficient sentence that front-loads the core purpose ('Get Instagram business profile information') and adds specific examples ('including followers, bio, and account details') without redundancy. Every word earns its place, making it highly 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 the lack of annotations and output schema, the description is incomplete. It doesn't explain what the return values include (beyond vague examples like 'followers'), error handling, or authentication needs. For a tool with no structured support, the description should provide more operational context to be fully helpful to 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?

The description adds no parameter-specific information beyond what the schema provides. The schema has 100% coverage with a clear description for the single optional parameter. Since the description doesn't elaborate on parameter usage (e.g., when to omit account_id), it meets the baseline of 3 where 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 verb ('Get') and resource ('Instagram business profile information') with specific examples of what information is retrieved ('followers, bio, and account details'). It distinguishes from siblings like 'get_account_insights' or 'get_media_posts' by focusing on general profile data rather than analytics or content. However, it doesn't explicitly contrast with 'business_discovery', which might also retrieve profile info, so it's not a perfect 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. It doesn't mention prerequisites (e.g., needing a business account), exclusions (e.g., not for personal profiles), or compare to siblings like 'business_discovery' or 'get_account_pages'. The agent must infer usage from the tool name and description alone, which is minimal.

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 tool retrieves 'current active stories' and notes expiration timing, but lacks critical details such as authentication requirements, rate limits, pagination behavior, error conditions, or what happens if account_id is omitted. For a read operation 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 appropriately concise with two sentences that each add value: the first states the core purpose, and the second provides important contextual information about story expiration. There's no wasted text, though it could be slightly more structured for 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 read tool with one optional parameter and no output schema, the description is minimally adequate. It covers what the tool does and adds useful context about story lifespan, but lacks completeness regarding behavioral aspects like authentication, response format, or error handling that would be helpful for an agent.

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

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

Schema description coverage is 100%, so the input schema fully documents the single optional parameter. The description doesn't add any parameter-specific information beyond what's in the schema, such as clarifying when account_id is needed or how it's obtained. Baseline 3 is appropriate when the schema handles parameter documentation.

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

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

The description clearly states the tool's purpose: 'Get current active stories on your Instagram account.' It specifies the verb ('Get'), resource ('stories'), and scope ('current active'), but doesn't explicitly differentiate from sibling tools like 'get_media_posts' or 'get_mentions' that might also retrieve Instagram content.

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 mentions that 'Stories expire after 24 hours,' which is contextual information but doesn't help the agent choose between this tool and other content-retrieval siblings like 'get_media_posts' or 'get_hashtag_media.'

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 for behavioral disclosure. It mentions the public visibility effect but omits critical details: whether this requires specific permissions, if it's reversible (though implied by 'unhide'), rate limits, or what happens when applied to already hidden/visible comments. The description is insufficient for a mutation tool with zero annotation coverage.

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

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

The description is perfectly concise with two sentences that each add value: the first states the action and resource, the second explains the consequence. There's no wasted language or redundancy.

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

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

For a mutation tool with no annotations and no output schema, the description is minimally adequate. It covers the basic purpose and effect but lacks details on permissions, error conditions, return values, or integration with sibling tools. The high schema coverage helps, but behavioral gaps remain significant.

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 input schema fully documents both parameters. The description adds no additional parameter semantics beyond what's in the schema (e.g., no examples, format details, or edge cases). 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 specific action ('hide or unhide'), the resource ('a comment on your Instagram post'), and the effect ('hidden comments are not visible to the public'). It distinguishes itself from sibling tools like 'delete_comment' by specifying a reversible visibility change rather than permanent removal.

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 managing comment visibility on Instagram posts, but provides no explicit guidance on when to use this tool versus alternatives like 'delete_comment' or 'reply_to_comment'. It also doesn't mention prerequisites such as authentication or ownership requirements.

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

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

With no annotations provided, the description carries the full burden. It discloses the required permission ('instagram_manage_comments permission'), which is a key behavioral trait for authorization. However, it lacks details on rate limits, error handling, or what happens on success (e.g., comment ID returned), leaving gaps in behavioral context.

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

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

The description is two sentences with zero waste: the first sentence states the purpose and scope, and the second adds critical permission information. It is 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?

Given no annotations and no output schema, the description is incomplete for a mutation tool. It covers the purpose and permission requirement but lacks details on return values, error cases, or side effects, which are important for an agent to use it correctly in 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 description coverage is 100%, so the schema already documents both parameters ('media_id' and 'message') with details like max length. The description does not add any additional semantic meaning beyond what the schema provides, such as examples or usage notes, meeting the baseline for high 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 action ('Post a top-level comment') and resource ('on an Instagram post'), distinguishing it from sibling tools like 'reply_to_comment' (which is for replies) and 'delete_comment' (which removes comments). It specifies the scope ('top-level') to differentiate from nested 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 explicitly states when to use it ('post a top-level comment') and includes a prerequisite ('Requires instagram_manage_comments permission'), but does not mention when not to use it or name specific alternatives like 'reply_to_comment' for replies, leaving some guidance implicit.

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

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

With no annotations, the description carries full burden. It mentions media must be publicly accessible URLs, which is useful context, but lacks critical behavioral details: whether this is a write operation (implied by 'Publish'), authentication needs, rate limits, error handling, or what happens on success (e.g., returns a post ID).

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 key constraint (2-10 items, public URLs). Every word earns its place with no redundancy or fluff.

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

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

For a write operation tool with no annotations and no output schema, the description is incomplete. It misses essential context: what the tool returns, error conditions, side effects, and how it differs behaviorally from sibling publishing tools, leaving gaps for an agent to use it correctly.

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

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

Schema description coverage is 100%, so the schema fully documents parameters. The description adds minimal value beyond schema: it reiterates the 2-10 range for image_urls and specifies 'images or videos', but doesn't clarify format requirements or caption usage beyond what's in 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 action ('Publish') and resource ('a carousel (album) post'), specifying it's for 2-10 images or videos. It distinguishes from siblings like publish_media or publish_reel by focusing on multi-media albums, but doesn't explicitly contrast them.

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 posting multiple media items (2-10) as a carousel, but provides no explicit guidance on when to choose this over publish_media or publish_reel, nor any prerequisites or exclusions beyond URL accessibility.

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 'upload and publish' which implies a write/mutation operation, but doesn't disclose critical behavioral traits like authentication requirements, rate limits, whether the action is reversible, error conditions, or what happens on success. The description adds minimal context beyond the basic action.

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. Every word earns its place - 'Upload and publish' establishes the action, 'image or video to Instagram' specifies the resource and platform, and 'with caption and optional location' highlights key parameters without redundancy.

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

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

For a mutation tool with no annotations and no output schema, the description is insufficient. It doesn't explain what happens after publishing (success response, media ID returned, error handling), authentication requirements, or platform-specific constraints. The 100% schema coverage helps with parameters, but behavioral and output context is missing.

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

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

Schema description coverage is 100%, so the schema already documents all parameters thoroughly. The description adds marginal value by mentioning 'caption and optional location' which echoes the schema, but doesn't provide additional semantic context like format requirements 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 ('Upload and publish'), the resource ('an image or video to Instagram'), and the key parameters ('with caption and optional location'). It distinguishes this tool from siblings like publish_carousel and publish_reel by specifying it's for single image/video posts, not carousels or reels.

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 (publishing to Instagram) but doesn't explicitly state when to use this tool versus alternatives like publish_carousel or publish_reel. It mentions optional parameters but provides no guidance on prerequisites, timing, or constraints beyond what's in the schema.

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 only states it's a publishing action. It doesn't disclose behavioral traits like required permissions, rate limits, whether it's idempotent, what happens on failure, or response format. The description is minimal and misses key operational 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?

Two concise sentences with zero waste: the first states the purpose, the second adds essential constraints. 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 incomplete. It lacks information about authentication needs, error handling, return values, or side effects. The technical constraints are noted, but overall context is insufficient for safe and effective use.

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

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

Schema description coverage is 100%, so the schema fully documents parameters. The description adds marginal value by implying 'video_url' must be publicly accessible and MP4 format, but doesn't provide additional semantics beyond what's in 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 action ('Publish') and resource ('Reel to Instagram') with specific format requirements ('MP4 format, publicly accessible URL'). It distinguishes from siblings like 'publish_carousel' and 'publish_media' by specifying 'Reel (short-form video)', though it doesn't explicitly contrast them.

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 like 'publish_media' or 'publish_carousel'. It mentions technical prerequisites ('publicly accessible URL, MP4 format') but lacks context about appropriate scenarios, 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?

With no annotations provided, the description carries the full burden of behavioral disclosure. It mentions the permission requirement, which is useful context, but lacks details on other behavioral traits such as rate limits, error handling, or what happens upon success (e.g., whether the reply is public or private). This leaves gaps in transparency for a mutation tool.

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

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

The description is a single, efficient sentence that directly states the tool's purpose and key requirement without any unnecessary words. It is front-loaded and appropriately sized, making it easy to understand 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 mutation with 2 parameters), no annotations, and no output schema, the description is somewhat complete but has gaps. It covers the action and permission need but lacks details on behavioral aspects like response format or error cases, making it adequate but not fully comprehensive for an agent's needs.

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

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

Schema description coverage is 100%, so the input schema already fully documents the parameters (comment_id and message). The description does not add any additional meaning or context beyond what the schema provides, such as examples or constraints not in the schema, 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 ('Reply to') and target ('a specific comment on an Instagram post'), making the purpose evident. However, it does not explicitly differentiate from sibling tools like 'post_comment' or 'reply_to_comment' (if present), which might handle similar actions, so it lacks sibling distinction for 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 clear context by specifying the required permission ('instagram_manage_comments'), which indicates when to use this tool based on access rights. It does not mention alternatives or exclusions, such as when not to use it versus other comment-related tools like 'post_comment', so it falls short of explicit guidance on alternatives.

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

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

No annotations are provided, so the description carries the full burden. It discloses the tool's purpose and output usage, but lacks details on behavioral traits such as rate limits, authentication needs, error handling, or whether it's a read-only operation (implied by 'search' but not explicit). The description adds some context but misses key operational aspects.

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 every sentence earns its place by providing essential information (search action and ID usage) without any 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 the tool's low complexity (1 parameter, no output schema, no annotations), the description is mostly complete for its purpose. It covers what the tool does and how to use the output, but lacks details on return values (since no output schema) and behavioral context, which slightly reduces completeness for an agent's needs.

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

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

Schema description coverage is 100%, so the schema already documents the parameter 'hashtag_name' with its description. The description does not add any meaning beyond what the schema provides (e.g., no examples, formatting tips, or constraints), meeting the baseline for high coverage without extra value.

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 for an Instagram hashtag') and the resource ('hashtag'), and it distinguishes from siblings by specifying the output ('get its ID') and its intended use ('Use the returned ID with get_hashtag_media'), which differentiates it from tools like 'business_discovery' or 'get_mentions' that handle other Instagram 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?

It explicitly states when to use this tool ('Search for an Instagram hashtag and get its ID') and provides a clear alternative or follow-up action ('Use the returned ID with get_hashtag_media'), which helps the agent understand the tool's role in a workflow without needing to infer from sibling 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?

With no annotations provided, the description carries the full burden of behavioral disclosure. It effectively communicates critical operational constraints: the required permission scope and the 24-hour reply window, which are essential for correct usage. However, it lacks details on rate limits, error conditions, 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?

The description is extremely concise and front-loaded with the core purpose, followed by essential constraints. Every sentence earns its place by providing critical information without any redundancy or fluff.

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

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

Given the tool's complexity (a mutation operation with no annotations and no output schema), the description is reasonably complete. It covers the action, prerequisites, and a key behavioral constraint. However, it could be more complete by mentioning potential error cases or the expected 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?

The schema description coverage is 100%, with clear parameter descriptions in the schema. The tool description does not add any additional semantic context about the parameters beyond what is already documented in the schema, such as explaining the format of 'recipient_id' or providing examples for 'message'.

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 ('Send Instagram direct message') and resource ('direct message'), distinguishing it from siblings like 'post_comment' or 'reply_to_comment' which involve public interactions rather than private messaging.

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 prerequisites ('Requires instagram_manage_messages with Advanced Access') and a temporal constraint ('Can only reply within 24 hours'), but does not explicitly state when to use this tool versus alternatives like 'get_conversation_messages' or 'get_conversations' for reading messages.

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 states the tool validates and checks permissions, but does not describe what happens during validation (e.g., returns token status, permissions list, or error messages), potential rate limits, or authentication requirements. This leaves significant gaps in understanding the tool's behavior.

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

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

The description is a single, efficient sentence with no wasted words. It is appropriately sized and front-loaded, clearly stating the tool's purpose without unnecessary elaboration, earning a 5.

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 (validation and permission checking), lack of annotations, and no output schema, the description is incomplete. It does not explain what the tool returns (e.g., validation result, permissions list) or behavioral details, making it inadequate for an agent to understand full usage. This scores a 2.

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 0 parameters with 100% coverage, so no parameters need documentation. The description does not add parameter details, but this is acceptable as there are no parameters to describe. Baseline for 0 parameters is 4, as the description does not need to compensate for missing schema information.

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

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

The description clearly states the tool's purpose: 'Validate the Instagram API access token and check permissions.' It specifies the verb (validate), resource (access token), and additional action (check permissions). However, it does not explicitly differentiate from sibling tools, as none appear to perform similar validation functions, so a 4 is appropriate.

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 does not mention prerequisites, such as needing an access token, or context for usage, like before making other API calls. Without any usage instructions, it scores a 2.

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