API Direct

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

With no annotations, the description fully carries the behavioral burden. It discloses concurrency, per-item status/body, input-order preservation, separate billing per item, unsupported endpoint inside a batch, potential latency for large batches, and a docs link. This is comprehensive and gives the agent confidence in side effects and cost 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?

Four sentences deliver all essential information: definition, example, concurrency and order, billing, exclusion, latency, and docs reference. No fluff, every sentence earns its place, and key facts are front-loaded. The structure is logical and scannable.

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

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

Given the tool has no output schema and no annotations, the description covers the critical context: what the tool does, how many items, mixing, concurrency, per-item result format, billing, limitation, potential long duration, and a link to full docs. This is complete enough for an agent to select and invoke the tool correctly.

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

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

The schema already provides 100% coverage of the only parameter, describing items, endpoint, params, and tag. The description adds an example and reiterates the mix of endpoints but doesn't provide new parameter-level semantics beyond the schema. Per the rubric, baseline 3 is appropriate when schema coverage is high.

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

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

The description uses a specific verb phrase 'Execute up to 100 API Direct requests in a single call' and clearly identifies the resource as a batch aggregation of other endpoints. It distinguishes from siblings by explaining it can mix any of the other tools' endpoints, with a concrete example (50 twitter_user_profile + 50 instagram_user_profile). This leaves no ambiguity about what the tool does.

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

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

It clearly states the primary use case (batching multiple API requests) and the limitations (no /v1/web/ai-mode, large batches can take minutes). However, it doesn't explicitly contrast with using individual endpoint tools directly, though the example and wording strongly imply the alternative. A direct statement like 'For single requests, use the specific endpoint tool' would earn a 5.

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

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

No annotations are present, so the description must carry the full burden. It only states 'Get', which implies a read-only operation, but provides no details about authentication requirements, rate limits, error behavior, or whether the group must be public. This lack of behavioral disclosure is a significant gap 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, clear sentence that immediately states the tool's purpose and key outputs. Every word earns its place, with no filler or redundancy.

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

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

For a simple 1-parameter read tool, the description gives a fair overview but omits an exhaustive list of return fields (uses 'including'), and does not mention edge cases like invalid URLs or access restrictions. Given the absence of an output schema, the description is minimally viable but has clear gaps in behavioral and output completeness.

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

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

The schema already provides 100% coverage by describing 'url' as 'Facebook group URL'. The description adds no extra meaning about the parameter, such as URL format or validation rules. Since schema coverage is high, the baseline is 3, and the description does not exceed that.

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

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

The description uses the specific verb 'Get' with the resource 'Facebook group details' and explicitly lists the key attributes returned (name, description, members count, privacy setting). This clearly distinguishes it from sibling tools like facebook_page_details or facebook_group_posts.

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

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

There is no guidance on when to use this tool versus alternatives. It does not mention scenarios where this tool is appropriate (e.g., retrieving metadata for a specific group) or when to prefer sibling tools like facebook_group_posts. No exclusions or alternative recommendations are provided.

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

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

With no annotations, the description carries the full burden for behavioral disclosure. It only states the basic action of fetching posts, without mentioning pagination, billing per page, rate limits, authentication requirements, or response format. The schema hints at some behaviors (e.g., pages, get_sentiment) but the description itself adds no contextual detail.

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

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

The description is a single, clear sentence that is front-loaded and free of fluff. However, it's extremely terse and could incorporate a bit more useful context (e.g., 'supports pagination and sentiment analysis') without becoming verbose. It's concise but borderline under-specified.

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 4 parameters, pagination, and optional sentiment analysis, and no output schema or annotations exist, the description is insufficient. It doesn't explain return values, billing implications, or how pages and sentiment affect results. The description is too minimal for a tool with this complexity.

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

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

Schema description coverage is 100%—all parameters have descriptions in the schema. The tool description itself adds no parameter semantics, but high schema coverage means the description doesn't need to compensate. Baseline of 3 is appropriate.

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

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

The description clearly states the tool retrieves posts from a public Facebook group, using a specific verb ('Get') and resource ('posts from a public Facebook group'). It distinguishes from sibling tools like facebook_group_details (group info) and search_facebook_posts (search across groups), so purpose is unambiguous.

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

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

The description provides no guidance on when to use this tool versus alternatives like search_facebook_posts, or any exclusions beyond the implicit 'public' constraint. It doesn't mention use cases, prerequisites (e.g., having a group ID), or scenarios where another tool would be more appropriate.

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 the burden of disclosing behavior. It implies a read-only operation via 'Get' and lists return fields, but does not explicitly mention that it has no side effects, handles invalid URLs, or requires authentication. The description adds some value but lacks explicit safety or error 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 sentence, immediately front-loaded with the verb and resource, and lists all relevant output fields without redundancy. Every word contributes meaning.

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 single-parameter tool with no output schema, the description adequately conveys what it does and returns. It does not mention error behavior or explicit read-only status, but given the low complexity and clear focus, it is nearly complete.

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

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

Schema coverage is 100% with a single 'url' parameter well-described in the schema (including an example). The tool description does not add extra parameter semantics beyond the schema, which is acceptable given full schema coverage. Baseline of 3 is appropriate.

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

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

The description clearly states the action ('Get') and resource ('detailed information about a Facebook page'), listing specific fields (name, followers, categories, contact info, verification status). This distinguishes it from sibling tools like facebook_page_posts and facebook_page_photos, which target different content 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 clear context about what information this tool retrieves, making it obvious for page metadata. While it does not explicitly mention alternatives or exclusions, the field list (e.g., followers, contact info) differentiates it from content-specific siblings, so the usage intent is clear.

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

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

No annotations are provided, so the description carries the full burden of behavioral disclosure. It only mentions 'get' without elaborating on pagination, rate limits, authentication requirements, or whether this is a read-only operation. The schema reveals a 'pages' parameter for pagination, but the description does not clarify that 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, direct sentence with no wordiness or redundancy. It focuses solely on the core action and resource, making it extremely 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?

For a simple listing tool, the description is minimally adequate, but it lacks context about return values or usage scenarios. Since there is no output schema and no annotations, the description should at least hint at what is returned (e.g., photo metadata/URLs) or when to choose this over sibling tools.

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% (both page_id and pages are documented with descriptions). The tool description itself adds no parameter meaning, but the schema already provides sufficient semantic detail, so the baseline of 3 applies.

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

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

The description 'Get photos from a Facebook page' clearly identifies the resource (Facebook page) and the specific data type (photos), distinguishing it from sibling tools like videos, reels, and posts. The verb 'get' is a bit generic but the resource and photo focus make the purpose clear.

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

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

No guidance is provided on when to use this tool versus alternatives such as facebook_page_videos or facebook_page_posts. There are no exclusions, examples, or contextual hints about the appropriate scenario for fetching photos.

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 fails to mention pagination, rate limits, the meaning of 'recent', authentication requirements, or the response format. The description is merely a restatement of the tool's basic function without adding behavioral context.

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

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

The description is a single, clear sentence with no fluff. It is front-loaded and instantly communicates the core purpose, achieving maximum efficiency.

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

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

The description is minimally adequate for a simple list tool, but it lacks key contextual details such as pagination behavior, billing implications, and filtering capabilities that are present in the schema yet not highlighted in the description. Given the absence of an output schema and annotations, the description should have provided more context 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 all parameters are already well-documented in the schema (e.g., 'pages' is explained as 'Number of pages to fetch (1-10, default 1). Billed per page.'). The description adds no additional parameter meaning, so 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 uses a specific verb ('Get') with a clear resource ('recent posts from a Facebook page') and the method of identification ('by page ID'). It distinguishes itself from sibling tools like facebook_page_photos, facebook_page_videos, and facebook_page_reviews by explicitly targeting posts rather than other content 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?

There is no guidance on when to use this tool versus alternatives such as search_facebook_posts or facebook_post_comments. No context is provided about typical use cases, limitations, or situations where another tool would be more appropriate.

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 must carry the full burden of behavioral disclosure. It only mentions the ID requirement but does not disclose that this is a read-only operation, any pagination behavior (despite a 'pages' parameter), or any response format. The description is silent on side effects, authentication, or billing beyond what is already 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 consists of two short sentences that are front-loaded with the main purpose and followed by a necessary prerequisite. There is no redundant wording, and every word contributes to the meaning. It is appropriately concise 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?

The tool has no output schema and no annotations, so the description should explain what the response looks like or how pagination works. It does neither. While the schema explains the 'pages' parameter, the description fails to state that the tool returns a paginated list of reels, leaving the agent uncertain about the return format and usage flow.

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% coverage with descriptions for all three parameters. The description adds no additional parameter semantics beyond restating the requirement for reels_page_id. Since the schema fully documents the parameters, a baseline of 3 is appropriate; the description does not add value beyond the schema.

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

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

The description clearly states the action ('Get reels') and the resource ('from a Facebook page'), making the tool's purpose immediately understandable. It distinguishes from siblings like facebook_page_posts or facebook_page_photos by naming 'reels', though it does not explicitly differentiate from facebook_page_videos, which could overlap.

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 clear usage prerequisite: 'Requires the reels_page_id from the page details endpoint.' This tells the agent that it must first call the page details endpoint to obtain the ID, offering clear context on when to use this tool. However, it does not explicitly exclude alternatives or state when not to use it, so it does not reach a 5.

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

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

With no annotations provided, the description carries the full burden of behavioral disclosure, but it states nothing beyond the basic action. It does not disclose pagination behavior (e.g., 'pages' parameter billed per page), optional sentiment analysis, the return format, or any potential limitations. The schema provides some parameter details, but the description itself adds no 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 a single concise sentence with no wasted words, front-loading the purpose. It is appropriately sized for a simple getter, though it could be slightly more informative without becoming verbose.

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

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

The description is too sparse for a tool with no output schema and 3 parameters. It does not explain what the return value contains (e.g., review texts, ratings, author info) or how results are paginated. Billing and sentiment surcharge are mentioned in the schema, but the description itself lacks this context. The agent cannot infer the full behavior without deeper schema inspection.

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

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

Schema description coverage is 100%, with each parameter (page_id, pages, get_sentiment) having a description in the schema. The tool description itself adds no parameter-related semantics beyond what the schema already provides, so 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 'Get reviews for a Facebook page' uses a specific verb ('Get') and resource ('reviews for a Facebook page'), clearly distinguishing it from sibling tools like facebook_page_posts, facebook_page_photos, and facebook_page_details. It is immediately obvious what this tool does.

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

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

The description provides no guidance on when to use this tool versus alternatives. It does not mention exclusions (e.g., 'for posts, use facebook_page_posts') or any contextual triggers. The intended usage is only implied by the tool name and description.

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

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

With no annotations provided, the description carries the full burden of behavioral disclosure. It only states the input requirement and the basic action; it does not disclose read-only status, pagination behavior, rate limits, error conditions, or what happens if no videos exist. The description adds little beyond what the tool name implies.

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 very short—two sentences—with the main action front-loaded. It avoids extraneous wording and every sentence adds value: the first states the action, the second a crucial prerequisite. The structure is efficient and to the point.

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

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

The tool has pagination and sentiment options, and no output schema is present. The description does not explain the return format, how pages are counted, the structure of sentiment results beyond what's in the schema, or any limitations. Given the lack of annotations and output schema, the description should provide more behavioral and result context but does not.

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

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

The schema already provides 100% coverage for all three parameters, including descriptions for pages, get_sentiment, and delegate_page_id. The description adds no extra parameter-specific meaning beyond what the schema already documents, so the high schema coverage baseline of 3 applies.

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

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

The description clearly states the tool retrieves videos from a Facebook page, with a specific verb ('Get') and resource. However, it does not explicitly distinguish from the sibling 'facebook_page_reels' tool, which also returns video content, so the purpose is clear but not fully 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 a prerequisite for usage ('Requires the delegate_page_id from the page details endpoint'), which helps the agent understand a dependency. However, it offers no guidance on when to prefer this tool over alternatives like facebook_page_reels or facebook_page_posts, nor any exclusions or contextual decision criteria.

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 bears the burden. It discloses that the tool is a read operation ('Get') and describes the return structure, but does not mention auth requirements, rate limits, pagination behavior, or potential errors. It provides some behavioral context but lacks depth expected for an unannotated 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, concise sentence that front-loads the action and resource. Every word adds value, with no repetition of schema details or extraneous information. It is 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?

With no output schema and no annotations, the description adequately covers the return values, which is the main missing piece. It lacks some details like pagination or error behavior, but those are partially covered by the schema (pages parameter). The description is sufficient for an agent to select and invoke the tool correctly in most cases.

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

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

The input schema covers 100% of parameters with descriptions, so the baseline is 3. The description adds no additional meaning about parameters beyond what the schema already states (e.g., post_id, pages, get_sentiment). It does not explain parameter nuances or relationships, so it does not exceed the baseline.

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 a specific verb ('Get') and resource ('comments on a Facebook post'), and differentiates from sibling comment tools by specifying 'Facebook post' and 'by post ID'. It also lists the exact return fields (text, author details, reaction/reply counts, date, attachment), making the purpose unambiguous.

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

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

The description implies usage (when you have a Facebook post ID and want comments) but does not explicitly state when to use this tool versus alternatives or when not to use it. No exclusions or alternative tools are mentioned, so guidance is only implicit from the name and context.

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

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

With no annotations, the description carries full disclosure burden. It explains the tool fills in user inputs, returns an ordered recipe to execute, and tells the agent to ask the user for inputs if omitted. It doesn't elaborate on return format or execution semantics, but covers the core behavior well.

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

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

Four sentences, each serving a distinct purpose: definition, return value, usage preference, and parameter routing. The front-loaded sentence captures the essence, and the structured guidance is dense without being verbose.

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

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

Given no output schema, the description compensates by explicitly stating the return value ('ordered recipe of tool calls') and the workflow with list_skills. It prepares the agent to execute the playbook and handle unnamed skills, covering all functional gaps.

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

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

Schema description coverage is 100%, so baseline is 3. The description adds value by giving a concrete example of inputs and skill_id, and clarifies that inputs are optional and what happens if omitted — going beyond the schema's static 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 opens with a specific verb+resource: 'Get a ready-made skill's step-by-step playbook' and clarifies it returns an 'ordered recipe of tool calls'. This clearly distinguishes it from sibling data-fetching/search tools and positions it as a meta-tool that produces executable instructions.

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

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

Explicitly says 'PREFER running a matching skill over improvising raw searches' and provides a decision tree: if the user names a skill, pass the skill_id directly; otherwise call list_skills first. This is textbook usage guidance with clear 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?

With no annotations, the description takes on the full burden of disclosure. It lists the returned fields and the cost per page, but does not mention rate limits, authentication needs, or error behavior. The read-only nature is implicit but not explicitly stated.

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 the first stating the purpose and the second listing return fields and cost. It is concise, well-structured, and contains no filler or redundancy.

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

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

The tool is relatively simple with three parameters and no output schema. The description compensates for the missing output schema by listing return fields and adds cost information. However, it lacks usage context, possible limitations, or any prerequisites, making it only minimally complete for an unannotated 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 already provides detailed descriptions for all three parameters, achieving 100% coverage. The description adds billing cost per page, but this is not a parameter semantic—it relates to the pages parameter. Therefore, the description adds little beyond the schema, matching 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 starts with 'Get comments from a YouTube video,' which clearly states the verb and resource. This distinguishes it from sibling tools like youtube_video_details and search_youtube, making its purpose unambiguous.

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

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

The description implies usage (fetching comments for a given video) but does not explicitly state when to use it over alternatives or provide exclusions. The billing note adds context but does not serve as usage 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 does add useful context about the response format (paragraphs, headings, lists, images, citations) and session continuation, but it omits details about rate limits, authentication, or potential side effects. The added transparency is adequate but not comprehensive.

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

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

The description is two sentences, front-loaded with the primary action and output, followed by essential continuation guidance. Every sentence earns its place and there is zero filler or redundancy.

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

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

Given the tool's moderate complexity and absence of output schema/annotations, the description covers the core input (prompt) and output structure explicitly. It also explains conversational state via session_token. Minor gaps remain, such as optional parameter behavior or error handling, but the description is largely sufficient for an agent to invoke the tool correctly.

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

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

The schema description coverage is 100%, so the baseline is 3. The description adds no additional parameter-level meaning beyond what the schema already states; session_token is mentioned in both, but no new semantics (e.g., formatting, constraints) are introduced in the description.

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

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

The description states a specific verb ('Send a prompt') and resource ('Google's AI Mode') and clearly defines the output (structured conversational reply with reply_parts and reference_links). It distinguishes itself from sibling search tools by emphasizing conversational context and structured citations, leaving no ambiguity about what the tool does.

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

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

The tool provides usage context by describing how to continue conversations via session_token, but it does not explicitly explain when to choose this tool over sibling search tools like search_web. Usage is implied rather than stated with alternatives or exclusions, so it only partially meets the bar for clear guidance.

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

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

The description discloses what the tool returns (caption, counts, media URLs, carousel slides, etc.) and the one-of-input constraint. With no annotations provided, the description carries the full burden; it does not mention authentication needs, rate limits, or error behavior. The 'Get' verb implies read-only, but operational aspects are not disclosed.

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

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

The description is three concise sentences. The first sentence front-loads the main purpose, the second enumerates key return fields, and the third provides the essential input constraint. No filler or redundant information.

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

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

Given the tool has no output schema and no annotations, the description lists the expected return fields (caption, counts, media URLs, etc.) and the input constraint, which is sufficient for basic usage. It lacks details on error handling, rate limits, or authentication, but these are not critical for initial tool selection. The description covers the core semantics of the tool well.

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

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

The schema already fully documents all three parameters with descriptions, giving high coverage. The description adds the crucial 'Provide exactly one of url or code' semantic, which is not expressed in the schema's optionality. This clarifies the mutual exclusivity and invalidity of providing both or neither, which is valuable beyond the schema.

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

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

The description clearly states the tool's purpose with a specific verb ('Get full details') and resource ('single Instagram post, reel, or IGTV video'), and identifies the input method (URL or shortcode). This distinguishes it from sibling tools like instagram_user_posts (multiple posts) and instagram_user_profile (user-level info).

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

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

The description clearly implies when to use the tool: when you need details for a single post by URL or code. It explicitly states the input constraint 'Provide exactly one of url or code,' which is a usage guideline for parameters. However, it does not explicitly name alternative tools or state when not to use it, so it lacks direct 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?

No annotations are present, so the description carries the behavioral burden. It discloses billing ('billed per page'), pagination ('up to 12 posts per page'), and input exclusivity ('exactly one of url or username'). It could also mention public profile requirements or rate limits, but the core operational behaviors are well covered.

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

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

The description is three sentences, each serving a distinct purpose: defining the operation, listing return contents, and stating constraints/billing. It is front-loaded with the primary action and contains zero filler.

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

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

With no output schema and no annotations, the description compensates by listing return contents (captions, engagement metrics, author metadata, hashtags, mentions) and operational constraints (page size, billing, mutual exclusivity). It covers the core usage needs for an agent to select and invoke the tool correctly.

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

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

Schema coverage is 100%, giving a baseline of 3. The description adds value by explicitly stating 'Provide exactly one of url or username,' which enforces a mutual exclusivity not encoded in the schema. It also contextualizes 'pages' with 'Up to 12 posts per page; billed per page,' and clarifies the optional 'get_sentiment' behavior ('Add AI sentiment analysis...').

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

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

The description opens with a specific verb ('Get') and clearly identifies the resource: 'a single Instagram user's recent posts and reels (their feed)' by URL or username. It distinguishes itself from siblings like instagram_user_profile (profile details) and instagram_post_details (single post) by specifying feed-level 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 implies usage for fetching a user's recent feed but doesn't explicitly state when to prefer this over alternatives. It provides parameter-level guidance ('Provide exactly one of url or username') but no sibling comparisons or exclusions. The context 'single user's...feed' gives some clarity, but no explicit when-to-use/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?

With no annotations provided, the description carries the full burden of behavioral disclosure. It explicitly states the input constraint (exactly one of username or URL) and enumerates the return fields, giving a clear picture of what the tool does. It does not mention rate limits, error conditions, or authentication, but for a straightforward read operation, this level is adequate beyond what is inferred from 'Get'.

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

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

The description is concise and well-structured: the first sentence declares purpose and input, the second sentence lists return fields and the required constraint. Every sentence adds value with no redundancy. It is front-loaded with the primary action and resource.

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

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

The tool is simple with only two parameters and no output schema. The description explicitly covers the return values, input constraints, and the tool's core functionality, which is sufficient. It does not delve into error handling or edge cases, but given the low complexity, the description is nearly complete. A small gap is the lack of mention of potential errors (e.g., user not found), but this is not a major omission.

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

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

The input schema already provides descriptions for both parameters, which contributes to a high schema coverage baseline of 3. The description adds the critical constraint 'Provide exactly one of username or url,' which is not expressed in the schema where both parameters are optional. This additional semantic guidance raises the score to 4.

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

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

The description clearly states the tool's function: 'Get the full profile for a single Instagram user by username or profile URL.' It lists the specific fields returned (biography, follow counts, verification, etc.), which distinguishes it from sibling tools like instagram_user_posts or search_instagram_users. This is a specific verb+resource with comprehensive scoping.

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

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

The description implies when to use the tool: when you need a complete profile for a single Instagram user. It does not explicitly name alternatives or state exclusions, but the context is clear enough. The instruction 'Provide exactly one of username or url' adds operational guidance. There's no misleading information, so a 4 is appropriate.

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 the burden of disclosing behavior. It lists the exact return fields, which is useful, but it does not disclose potential failure scenarios (e.g., invalid URL, missing data) or whether any special permissions are required. The behavior is a simple read, but edge cases are not addressed.

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

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

The description is a single, front-loaded sentence that directly states the action and lists the return fields. Every word contributes to understanding, with no redundancy or unnecessary detail.

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

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

For a simple tool with one parameter and no output schema, the description adequately covers input (URL) and output (specific fields). It does not mention error handling or the need for prior search, but given the low complexity, the description is sufficiently complete.

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

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

The input schema already provides 100% coverage for the url parameter with a description ('LinkedIn company page URL'). The tool description merely repeats 'by URL' without adding extra meaning, such as URL format examples or constraints. Since schema fully documents the parameter, baseline 3 is appropriate.

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

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

The description explicitly states 'Get detailed information about a LinkedIn company page by URL' and enumerates the specific fields returned (name, description, employee count, etc.). This clearly distinguishes it from siblings like linkedin_company_posts (posts) and search_linkedin_companies (search).

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

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

The description clearly implies the use case: you need a LinkedIn company URL to retrieve detailed metadata. It mentions the URL requirement but does not explicitly contrast with alternatives such as search_linkedin_companies or note when not to use the tool. Context is clear, but exclusions are missing.

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

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

No annotations are provided, so the description must carry the burden. It discloses the return content (posts with engagement metrics: likes, comments, shares, reactions), but doesn't mention pagination behavior, rate limits, or any side effects. The description is adequate but not rich on behavioral detail.

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

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

The description is extremely concise: one sentence that states the core function and return value. Every word earns its place, with no unnecessary elaboration or repetition of schema details.

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

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

For a simple fetch-posts tool, the description provides the essential return information (engagement metrics). It lacks details about pagination defaults or potential limitations, but the schema covers the page parameter and no output schema exists. Given the low complexity and good schema coverage, this is fairly complete.

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

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

The input schema fully documents all three parameters (url, page, get_sentiment) with descriptions, providing 100% coverage. The description itself doesn't add additional meaning beyond what the schema already provides, so the baseline score of 3 applies.

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

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

The description clearly states the tool retrieves recent posts from a LinkedIn company page by URL, with a specific resource (company posts) and verb (Get). It distinguishes itself from siblings like linkedin_company_details and linkedin_person_posts by focusing on company page posts.

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

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

The description provides clear context: use this tool when you need recent posts from a LinkedIn company page identified by URL. It doesn't explicitly mention alternatives or exclusions, but the scope is well defined and the sibling list naturally differentiates it from person posts or company details.

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

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

With no annotations provided, the description carries the full burden. It discloses that the tool returns a comprehensive set of fields (title, company, location, date, type, etc.), giving the agent a clear picture of the response behavior. The word 'Get' implies a read-only operation, though it does not explicitly state non-destructiveness or error conditions. Still, it provides substantial 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 a single, focused sentence that front-loads the action ('Get detailed information') followed by the resource and a concise list of returned fields. Every word adds value, with no redundant or verbose phrasing.

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

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

This is a simple single-parameter read tool with no output schema and no annotations. The description fully covers what the tool does, how it is invoked (URL or ID), and what it returns (all major job attributes). For its complexity level, the description is complete and self-sufficient.

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

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

Schema description coverage is 100%, with the url parameter already described as 'LinkedIn job URL ... or numeric job ID.' The tool description adds no new parameter semantics beyond repeating that the input can be a URL or numeric ID. This meets the baseline for parameters already well-documented in the schema, but does not elevate it.

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

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

The description uses a specific verb and resource: 'Get detailed information about a specific LinkedIn job listing.' It clearly differentiates from sibling tools like search_linkedin_jobs by focusing on a specific listing by URL or ID. It also enumerates the returned data fields, making the tool's purpose unambiguous.

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

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

The description clearly implies when to use this tool: when you have a LinkedIn job URL or numeric job ID and need detailed information. It does not explicitly mention alternatives or exclusions, but the 'by URL or numeric job ID' qualifier provides clear context that this is for retrieving a single job's details, not for searching or listing jobs.

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?

Without annotations, the description carries the full burden for disclosing behavior. It does mention that it returns engagement metrics, author info, images, videos, and articles, which gives insight into the output. However, it does not disclose any limitations, side effects, or contextual details such as rate limits, authentication requirements, or the fact that it returns only a limited window of recent posts. This is moderate transparency for a read-only 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 sentence that covers the core action and the main return payload. It is front-loaded with the most important information and contains no redundant or extraneous phrases, earning a top score for efficiency.

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

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

Given that there is no output schema, the description does a decent job of outlining what results are included (engagement metrics, images, videos, articles). It also aligns with the schema for pagination via the 'page' parameter, which is described. It could be more complete by mentioning the sentiment analysis option or any limitations, but overall it provides sufficient context for a simple read tool.

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

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

Schema coverage is 100%, so the parameter descriptions in the input schema fully document each parameter. The tool description adds minimal semantic value beyond the schema—it rephrases the 'url' parameter as 'profile URL or public slug', which is already stated in the schema. Since the schema already does the heavy lifting, the baseline of 3 is appropriate.

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

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

The description clearly states the tool's function with a specific verb ('Get') and resource ('recent posts authored by a LinkedIn person'), and distinguishes it from sibling tools like linkedin_company_posts by specifying 'person' rather than 'company'. It also lists the types of content returned (engagement metrics, author info, images, etc.), making the purpose unambiguous.

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

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

The description gives clear context: this is for retrieving posts by a LinkedIn person using a URL or slug. It does not explicitly mention when not to use it or name alternatives, but the sibling context (e.g., linkedin_company_posts, linkedin_post_details) and the phrase 'authored by a LinkedIn person' imply the appropriate use case. This falls between 'clear context, no exclusions' and 'implied usage,' warranting a 4.

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 burden of signaling safety. The verb 'Get' and the promise to 'Return' data clearly indicate a read-only operation. It also discloses what the user will receive (post text, author details, engagement metrics), giving a transparent view of the output. It does not mention limitations like missing public posts or rate limits, but for a read operation this is adequate.

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 tight sentences front-loaded with exactly what the tool does. Every phrase adds value—'specific', 'by URL', and the list of returned data—without any redundant or filler wording.

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

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

With no output schema and no annotations, the description does a good job explaining the return value and distinguishing itself from sibling tools. It lacks explicit mention of the optional get_sentiment behavior (though that is covered in the schema) and potential edge cases like invalid URLs, but overall it is sufficiently complete for a straightforward read 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%—both 'url' and 'get_sentiment' have clear descriptions in the schema. The tool description adds no new parameter-specific meaning beyond what the schema already provides, so the baseline 3 applies. The only slight addition is that 'by URL' reinforces the purpose of the url parameter.

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

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

The description clearly specifies the action ('Get detailed information') and the exact resource ('a specific LinkedIn post by URL'). It also lists the key output content (full post text, author details, engagement metrics), which distinguishes it from sibling tools that search or list posts rather than fetch details 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 phrase 'by URL' provides clear context for when to invoke this tool: whenever you have a direct LinkedIn post URL and want its details. It does not explicitly state alternatives or exclusions, but the scope is unmistakable given the 'specific LinkedIn post by URL' wording.

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 the burden. It explains that the tool lists skills and details the return contents (id, name, category, description, inputs), plus it clarifies that the tool is a starting point and that skills are playbooks. It does not disclose potential pagination, rate limits, or error behavior, but for a simple listing tool, the behavioral transparency is strong.

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 with 'START HERE' and clearly structured in four sentences covering purpose, usage, return value, and next step. It is somewhat verbose due to long enumerations of outcomes and use cases, but every sentence contributes value, so it earns a 4 rather than 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?

The description is complete for a simple tool: it explains what the tool does, when to use it, what it returns, and how to proceed (via get_skill). Since there is no output schema, the description's explicit mention of return fields adequately compensates. The guidance about common goals and playbooks adds rich 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 fully covers the only optional parameter 'category' with examples ('sales', 'recruiting', etc.), so schema coverage is 100%. The main description does not add anything about the parameter, but the baseline of 3 applies because the schema does the heavy lifting.

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

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

The description clearly states that the tool 'Lists the ready-made API Direct skills' and explicitly enumerates what it returns ('each skill's id, name, category, what it does, and its inputs'). It also distinguishes itself from siblings by positioning as the entry point and referencing get_skill for running a skill, making the purpose unambiguous.

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

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

The description provides explicit when-to-use guidance: 'Whenever the user's request looks like lead-gen, competitor/brand monitoring, recruiting, due diligence, deal sourcing or market research, call this FIRST to check for a matching playbook before improvising your own searches.' It names an alternative (improvising searches) and suggests a follow-up action (get_skill), though it does not explicitly state when not to use the tool.

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

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

With no annotations, the description carries the full burden. It discloses the read-only nature ('Get'), and details the return payload including a website scrape, photos sample, owner info, and more, giving a transparent behavioral picture.

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

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

One sentence, front-loaded with the core purpose, followed by a detailed yet relevant list of return fields. Every clause adds value and the length is justified by the tool's comprehensive nature.

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

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

Given no output schema or annotations, the description is exceptionally complete: it enumerates the return fields, mentions the website scrape, and ties the input to search_places. This is sufficient for an agent to select and invoke the tool correctly.

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

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

Schema coverage is 100%, so baseline is 3. The description adds valuable semantics by explaining that place_id is the ChIJ... value from search_places, clarifying how agents should source this parameter. It also implies that country and language affect the returned details.

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

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

The description starts with 'Get full details for a Google Maps place by place_id', using a specific verb and resource. It clearly identifies the input (ChIJ... value from search_places) and distinguishes itself from sibling tools like place_photos and place_reviews by returning a comprehensive set of 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 states that place_id is the value returned by search_places, providing clear prerequisite context. It does not explicitly name alternative tools or when-not-to-use, but the 'full details' scope makes the tool's niche unambiguous.

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

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

With no annotations provided, the description carries the full burden of behavioral disclosure. It reveals that photos and videos are returned together, that pagination works in pages of up to 10 items billed per request, and that results include URLs, coordinates, and timestamps. It stops short of discussing rate limits, authentication, or the meaning of 'type' values, but the disclosed behavior is substantial and accurate.

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

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

Three sentences, all information-dense and front-loaded. The first sentence states the primary purpose, the second details return fields and the media-type caveat, and the third explains pagination. No filler or repetition of schema fields.

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 absence of an output schema, the description does well to mention the key returned fields (URLs, coordinates, timestamps) and clarify that the type field must be filtered client-side. It also explains pagination and billing. It could have added error conditions or examples of valid place_id, but for a read-only listing tool this is quite complete.

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

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

The input schema already provides 100% coverage for all four parameters, so the description's additional value on parameters is limited. It does reinforce the meaning of the pages parameter ('each page returns up to 10 items and is billed as one request'), but this information already exists in the schema description. Baseline 3 is appropriate when the schema is comprehensive.

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

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

The description opens with a specific verb ('Get') and resource ('photos and videos for a Google Maps place by place_id'), clearly differentiating from sibling tools like place_details or place_reviews. It also lists the main return fields (URLs, coordinates, timestamps), leaving no ambiguity about what the tool does.

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

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

The description provides clear context for use: it is keyed by place_id, returns both photos and videos together, and instructs the client to filter by type. It also explains pagination behavior with the pages parameter. However, it does not explicitly state when to use this tool versus alternative media-fetching tools (e.g., if sibling tools also return media), though this is minor given the clear scope.

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 discloses page size limits (up to 10 reviews per page), the language filtering semantics (originally written language), and the interaction between sort_by and pagination. This goes beyond the schema and gives users meaningful behavioral expectations.

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

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

The description is three concise sentences, front-loaded with the primary action and place_id requirement. It packs essential details (review contents, pagination, language filtering, sort behavior) without redundancy or fluff.

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

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

Given no output schema and no annotations, the description adequately covers what reviews contain, pagination limits, and parameter behaviors. It does not mention sentiment analysis or translation, but the schema descriptions for those parameters suffice. The description is complete enough for a focused, read-only tool.

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

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

Schema coverage is 100%, so baseline is 3. The description adds value by clarifying the language parameter with concrete examples (fr returns French reviews only) and explaining the strategic use of sort_by to surface more reviews. This enriches parameter understanding beyond 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 uses a specific verb ('Get') and resource ('user reviews for a Google Maps place by place_id'), clearly distinguishing it from sibling tools like place_details or place_photos. It immediately establishes the tool's core function and 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 for use (fetching Google Maps reviews by place_id) and gives practical guidance on combining sort_by with multiple pages to surface a larger review pool. It does not explicitly contrast with sibling tools, but this is fairly obvious given the focused purpose.

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, but it only states the core search action and optional location scoping. It does not mention pagination, return format, rate limits, or any side effects beyond what is in the schema.

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

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

The description is two short sentences, front-loaded with the main action and a clear optional modifier. Every word serves a purpose, with no redundancy or filler.

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

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

For a tool with 5 parameters and no output schema or annotations, the description provides the essential purpose but omits any mention of date filtering, pagination behavior, or what the response looks like. It is minimally viable but leaves room for richer 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 baseline is 3. The description adds minor value by explaining the purpose of location_id and how to resolve it via a sibling tool, but it does not enrich other parameter semantics beyond the schema.

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

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

The description clearly states the tool searches Facebook events by keyword, using a specific verb and resource. It naturally distinguishes itself from sibling Facebook search tools (pages, posts, videos, locations) by specifying 'events'.

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 points to search_facebook_locations for resolving location IDs, giving clear guidance on how to use the optional location scoping. It does not contrast with other search tools, but the context is clear enough for a focused search tool.

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

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

No annotations exist, so the description is the only behavioral disclosure. It explains the output's purpose but does not mention handling of ambiguous names, multiple matching locations, no-result cases, or exact return format—important gaps for a resolver.

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, purpose first, every word earns its place. It is brief and highly scannable.

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

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

For a single-parameter resolver, the description fully covers purpose, input scope, and output usage via downstream tool references. No output schema is needed when the description points to the exact consumers.

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

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

Schema already defines 'query' with a description and max length. The description adds semantic narrowing by specifying accepted entity types (city, region, country), which is extra value beyond the schema.

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

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

The description uses a specific verb 'Resolve' and clearly states the resource (place name to Facebook location IDs). It distinguishes this from sibling content-search tools by framing it as a preparatory lookup step.

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

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

Explicitly tells when to use the tool (to obtain a location ID for scoping searches) and names two direct consumer tools (search_facebook_posts, search_facebook_events). This provides clear integration context and implicitly contrasts with alternative search tools.

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

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

No annotations exist, so the description must carry the burden of behavioral disclosure. It only states the action, with no mention of pagination, billing per page (though the schema notes it), rate limits, or return behavior. The description adds no transparency beyond the schema.

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

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

The description is a single, efficient sentence with the verb front-loaded. It is concise, though perhaps overly minimal, but it earns a 4 for its economy and 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?

Given the lack of annotations and output schema, the description should explain expected results, pagination behavior, or billing implications. It does none of that. The tool is simple, but the description still leaves the agent with incomplete context for a robust search operation.

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

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

Schema description coverage is 100%, so the baseline is 3. The description itself adds no parameter semantics beyond what the schema already provides; it just says 'by keyword' which mirrors the query parameter.

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

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

The description clearly states the verb 'search' and resource 'Facebook pages' with a qualifier 'by keyword'. It is unambiguous but does not distinguish itself from sibling tools like search_facebook_posts or search_facebook_events, warranting a 4 rather than a 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?

No guidance is provided on when to use this tool versus alternatives. There is no mention of exclusions or preferred scenarios, leaving the agent to infer usage from the 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?

No annotations are provided, leaving the description to carry the full burden of behavioral disclosure. It only states the search scope and optional location filtering, but does not mention return format, pagination, rate limits, cost (beyond what the schema says), or whether this is a read-only operation. The agent is left guessing about key behavioral 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 exactly two sentences: the first states the core purpose, the second adds an optional scoping capability with a helpful reference. There is no redundant or filler content, and key information is front-loaded.

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

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

The tool has 7 parameters and no output schema, yet the description is minimal. It does not explain what the returned posts contain, how pagination (pages parameter) impacts results, or the cost implications that the schema only hints at. For an agent to fully assess the tool, more contextual detail is needed.

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

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

Schema coverage is 100%, so every parameter is already described in the input schema. The description's mention of location_id and the pointer to search_facebook_locations adds no new semantic detail beyond the schema. It satisfies the baseline but does not 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 action ('Search Facebook posts by keyword') and the scope ('across all of Facebook'), distinguishing it from siblings like search_facebook_pages and search_facebook_videos by specifically targeting posts. It also notes the optional location scoping, which adds precision.

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

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

The description provides a concrete usage hint: use search_facebook_locations to resolve a location_id for scoped results, giving an explicit path for a common need. However, it does not contrast with other Facebook search tools (pages, videos, etc.), so broader usage differentiation is implied rather than stated.

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 must carry the burden of behavioral disclosure, but it only states a high-level purpose. It omits important behaviors like pagination, billing implications, result format, or that sentiment analysis changes output. The schema provides some detail, but the description itself adds no 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 a single, clear sentence with no redundant information. It is extremely concise and easy to parse, effectively communicating the core purpose without unnecessary flourishes.

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

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

Despite having 6 parameters and no output schema or annotations, the description provides only a minimal summary. It does not explain what results look like, how to scope searches, or why an agent might prefer this over sibling tools. The omission of pagination behavior and billing implications (though mentioned in the schema) leaves the tool under-specified for a complex search operation.

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

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

Schema description coverage is 100%, so the baseline is 3. The schema already provides detailed descriptions for all parameters, including default values, enums, and billing notes. The description adds no additional parameter context, so it neither improves nor harms the semantics.

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

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

The description clearly states the tool's function: 'Search Facebook videos by keyword.' It uses a specific verb (search) and identifies the resource (Facebook videos) and the query method (by keyword), which distinguishes it from sibling tools like facebook_page_videos or search_facebook_posts.

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

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

No guidance is provided on when to use this tool versus alternatives. It does not mention exclusions, prerequisites, or refer to sibling tools. For a tool with many close siblings (e.g., search_facebook_posts, facebook_page_videos), this is a clear gap.

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

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

With no annotations, the description must disclose behavioral traits. It only says 'search forum posts across the web' and provides no details on pagination, filtering behavior, response format, or rate limits. It does not contradict safety expectations but lacks 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 very short (six words) and front-loads the verb. It is efficient but under-specified, lacking details that could be added without verbosity. The brevity is appropriate but leaves room for more useful content.

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 large set of sibling search tools and no output schema, the description is insufficient. It does not explain what types of forums are covered, how results are structured, or what differentiates it from similar tools, making tool selection harder.

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

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

Schema description coverage is 100%, and parameter descriptions are clear (e.g., page default, time enum, query max length, sentiment surcharge). The description adds no extra semantic value over the schema, so the baseline of 3 applies.

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

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

The description clearly states the tool's function: 'Search forum posts across the web.' It uses a specific verb (search) and a specific resource (forum posts), distinguishing it from broad search tools like search_web or platform-specific ones like search_reddit, though it doesn't explicitly name alternatives.

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

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

No guidance is provided on when to use this tool versus sibling tools. It does not mention alternative tools, exclusions, prerequisites, or typical use cases beyond the generic 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?

With no annotations, the description carries the full burden of behavioral disclosure, but it only states 'Search Instagram posts by keyword.' It does not mention pagination behavior, rate limits, costs, or that the get_sentiment parameter adds a surcharge. The parameter descriptions cover some details, but the description itself adds no behavioral 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, well-formed sentence with no unnecessary words. Every word earns its place: 'Search', 'Instagram posts', and 'by keyword' all contribute essential information. There is no padding or redundancy, making it highly concise and easy to process.

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 output schema and no annotations, the description is under-specified. It fails to mention what a successful search returns (e.g., post metadata, authors, timestamps), any limitations beyond the schema's max characters, or when the tool should be preferred over similar search tools. Given the richness of sibling tools, this minimal description leaves significant gaps in the agent's understanding of the tool's complete behavior.

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

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

Schema coverage is 100%, so the baseline is 3. The description does not add any parameter semantics beyond what the schema already provides—'query' is described as a search keyword, 'pages' as page count, and 'get_sentiment' as sentiment analysis. The description merely restates the action, offering no additional insight into parameter usage or relationships.

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

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

The description uses the specific verb 'search' with resource 'Instagram posts' and qualifier 'by keyword', clearly distinguishing it from sibling tools like search_instagram_users (searches users) and instagram_post_details (details on a specific post). This is a precise and unambiguous statement of purpose.

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

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

The description implies usage when the user needs to find Instagram posts matching a keyword, but it does not explicitly mention alternatives or exclusions. For example, it does not state when to use this instead of search_instagram_users or instagram_user_posts. The guidance is implied rather than explicit, and there are no exclusions or alternative tool references.

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 must disclose behavioral traits. It only lists return fields and does not mention pagination, result limits, sorting, or read-only nature. For a search endpoint, this leaves important behavior unspecified.

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

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

The description is a single, front-loaded sentence with no redundant words. It efficiently conveys purpose and output fields.

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 one-parameter search tool, the description is mostly complete: it states what it searches, the input, and what is returned. It could be improved by clarifying whether results are a list, but the lack of output schema makes the listed fields helpful enough.

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

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

The schema covers the single parameter query with 'Search keyword (max 500 characters)' and the description simply repeats 'by keyword'. No additional semantic value is added beyond the schema.

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

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

The description clearly states the action ('Search Instagram users') with a specific resource and modifier ('by keyword'), and lists the returned fields. This distinguishes it from broader search tools like search_instagram.

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

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

No guidance is provided on when to use this tool versus alternatives such as search_instagram or instagram_user_profile. The description gives no context for choosing it over sibling search tools.

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

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

With no annotations, the description carries the burden. It discloses return fields (post content, engagement metrics, media, repost flag, optional AI sentiment), notes the need for at least one search criterion, and mentions that some filters apply "alongside a query." It does not mention rate limits or auth, but for a read-only search tool this is acceptable. The schema covers cost of sentiment, so no criticism.

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

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

The description is compact: a clear opening sentence, a usage instruction, a list of key filters, and a summary of return fields. No wasted words, and it is well front-loaded with the core purpose. Each sentence contributes meaningful information.

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

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

For an 11-parameter tool with no output schema, the description covers the essential usage context: it names the main filters, explains the query/filter requirement, and summarizes what is returned. It references a sibling tool for company IDs. It does not go into pagination details, but those are in the schema. Overall, sufficiently complete 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 baseline is 3. The description adds semantic value by grouping filters into concepts (e.g., distinguishing "posts BY a person" vs "posts that MENTION a person"), clarifying that author_title and author_industry apply alongside a query, and giving examples for author_title. This goes beyond the schema's individual field descriptions.

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

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

The description opens with a specific verb+resource: "Search LinkedIn posts." It clearly distinguishes this from sibling tools like search_linkedin_companies and search_linkedin_jobs by focusing on posts. It also enumerates the scope (filters, returns) making the purpose unambiguous.

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

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

The description says "Provide a `query` and/or a filter below," indicating a required condition for usage. It also points to search_linkedin_companies for company IDs, providing a cross-tool reference. However, it does not explicitly state when to use this tool over other search tools, though the name and context make it reasonably clear.

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

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

With no annotations, the description must carry the full behavioral disclosure burden. It mentions return fields (name, description, followers, logo) but omits key behavioral traits such as whether the operation is read-only, authentication requirements, rate limits, or pagination specifics beyond the schema. The word 'search' implies read-only, but no explicit safety guarantees are provided.

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

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

The description is two concise yet informative sentences. It front-loads the action and return summary without any filler or redundant details, 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 simple two-param search tool, the description is minimally adequate: it states what is searched, how (by keyword), and what is returned. However, it lacks usage guidance and behavioral transparency, which leaves gaps in selection confidence and invocation safety. No output schema exists, so the return field enumeration is helpful but not comprehensive.

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 both params (query and page) already well-documented in the input schema. The description adds minimal value for parameter understanding, only indirectly reinforcing the role of 'query' as a keyword. Baseline 3 applies due to complete 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 uses a specific verb ('Search') and resource ('LinkedIn companies'), with the keyword-based scope clearly stated. It is easily distinguished from sibling tools like search_linkedin (general) and search_linkedin_jobs (jobs), and its functionality is unambiguous.

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

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

The description implies usage for keyword-based company searches but provides no explicit guidance on when to prefer this tool over alternatives like search_linkedin or linkedin_company_details. No when-not-to-use conditions or alternative suggestions are given.

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

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

With no annotations provided, the description carries the full burden. It discloses key behavioral aspects: what it searches, what it returns (title, company, location, etc.), and available filters (recency, job type, company, location). It does not explicitly state read-only behavior or rate limits, but search operation is inherently read-only and the description transparently lists outputs and filter capabilities.

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 purpose, then return values, filters, and use case. Every sentence earns its place without redundancy, 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 tool has 7 parameters and no output schema, the description covers the essential return fields and filters, satisfying most informational needs. It does not mention pagination or sort options, but these are documented in the schema. The use-case signal adds valuable context, making it fairly complete for its complexity.

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

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

Schema coverage is 100%, so the baseline is 3. The description adds context by mapping filters to parameter categories (recency, job type, company, location), but does not add significant meaning beyond the schema's parameter descriptions. It reinforces which parameters matter but provides no extra syntax or format details.

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

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

The description clearly states the tool searches LinkedIn job listings by keyword, which is a specific verb+resource. It distinguishes itself from siblings like search_linkedin_companies and linkedin_job_details by explicitly focusing on jobs and listing the returned fields and filters, making its scope unmistakable.

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

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

The description provides clear context for when to use this tool: 'useful as a hiring/expansion/funding signal.' It does not explicitly mention when not to use it or alternatives, but the context and return-field list make the intended use case clear. No exclusions are provided, so it falls short of a 5.

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

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

Since no annotations are provided, the description carries the full burden. It only states what is searched, but doesn't disclose any behavior beyond that, such as how results are returned, whether filters apply by default, or any limitations like rate limits or source diversity.

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

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

The description is a single sentence, front-loaded with the verb, and contains no extraneous information. It is appropriately sized for a straightforward search tool.

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

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

The description is minimal but sufficient for a simple search tool. It could benefit from mentioning the type of results returned or that filters exist, but the schema compensates by documenting all parameters. Given no output schema or annotations, a bit more context would be ideal, but it remains acceptable.

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

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

Schema description coverage is 100% with each parameter having its own description. The tool description adds no parameter-specific meaning, so the baseline of 3 applies. It doesn't hinder understanding, but also doesn't provide any extra semantic clarity.

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 and resource: 'Search news articles'. This distinguishes it from siblings like search_web or search_reddit, but doesn't explicitly name alternatives. The addition of 'thousands of sources worldwide' adds 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?

No usage guidance is provided. The description doesn't explain when to choose this tool over other search tools, nor does it offer any alternatives or exclusions. The agent gets no help in deciding between search_news and search_web for a query.

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 the full transparency burden. It discloses pagination behavior ('Each page returns up to 10 results'), optional geographic biasing, and the return data fields. This is solid coverage for a read-only search tool, though it omits details like rate limits or failure modes.

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

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

The description is exactly three sentences, front-loaded with the tool's purpose, and every sentence adds value. It lists return fields, notes geographic biasing, and states pagination in a compact, readable format.

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

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

The tool has 7 parameters and no output schema, so the description must compensate. It lists the key return fields, explains the optional bias mechanism, and notes page size. It does not cover edge cases or limits, but for a search tool this is adequate 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 already covers 100% of parameters with descriptions, so the baseline is 3. The description adds a modest group-level semantic for lat/lng/zoom ('bias results by geographic center') and reiterates pagination, but does not introduce meaning beyond the schema.

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

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

The description clearly states the tool searches Google Maps places (local businesses, points of interest) via free-text query, and enumerates the return fields. This specific verb-resource-scope pairing distinguishes it from sibling tools like search_web or place_details.

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

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

The description implies usage for finding places on Google Maps, and the geographic bias option gives a clear use case. It does not explicitly mention alternatives or exclusions, but the context is strong enough that an agent would know when to invoke it.

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

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

With no annotations, the description carries the full burden of behavioral disclosure, but it only states 'Search Reddit posts.' It doesn't disclose pagination limits, sorting options, sentiment analysis behavior, or any potential side effects such as authentication requirements or rate limits.

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

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

The description is a single short sentence, which is concise, but it is under-specified. It doesn't waste words, yet it also fails to provide meaningful context beyond the tool's name; it's borderline under-specification rather than effective conciseness.

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

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

Given that there are no annotations, no output schema, and 4 parameters (one with an enum and one boolean for sentiment), the description is too sparse. It doesn't explain return values, sorting behavior, or when to use this tool over other search tools, making it incomplete for smooth agent invocation.

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

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

The input schema covers 100% of the parameters with descriptions, so the description doesn't need to add much. The description itself adds no parameter-level meaning, only the schema descriptions do, which is the baseline for full 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 'Search Reddit posts.' uses a specific verb (search) and resource (Reddit posts), clearly distinguishing it from sibling tools like search_reddit_comments and search_reddit_users. However, it lacks any additional scope details that would fully separate it from other search tools in the family.

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 that search_reddit_comments or search_reddit_users should be used for those specific search needs, nor does it state any exclusions or prerequisites.

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 must carry the full burden of behavioral disclosure. It provides none—no mention of pagination, result limits, rate limits, or any side effects. The agent cannot infer the tool's behavior beyond the literal act of searching.

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

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

The description is a single, short sentence, which is concise but under-specified. It repeats the tool name without adding substantive information, so it fails to earn its place as a useful 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?

The tool has four parameters, including pagination and sentiment analysis, but the description provides no context about return values, limitations, or the sentiment feature. Given the absence of an output schema and annotations, the description is completely inadequate for an agent to use this tool 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 parameters are fully documented in the schema. The description adds no parameter details, but the baseline of 3 is appropriate because the schema handles parameter semantics entirely.

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 'Search Reddit comments' is a direct restatement of the tool name, providing no additional detail about the scope or behavior. It does not distinguish itself from sibling tools like 'search_reddit' or 'search_reddit_users', making it essentially tautological.

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

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

The description gives no indication of when to use this tool versus alternatives. It lacks any context about use cases, prerequisites, or exclusions, leaving the agent without guidance on tool 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 disclosure. It states that profile data is returned (username, karma, account age, bio), but does not mention whether this is a read-only operation, rate limits, pagination, or any side effects. For a simple search tool, the basic return info is useful but not exhaustive.

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

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

Two short sentences, front-loaded with the main purpose. No filler or redundancy; every word adds value.

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

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

For a simple one-parameter search tool, the description is fairly complete: it states the action, the target resource, and the returned fields. However, it lacks mentions of result limits, sorting, or potential ambiguity (singular vs. plural profiles), which would improve completeness.

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

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

Input schema has 100% coverage: the 'query' parameter is described as 'Search keyword (max 500 characters)'. The description's 'by keyword' adds little beyond the schema. Baseline 3 applies because schema adequately documents the parameter.

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

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

Description clearly states the action ('Search Reddit users by keyword') and the resource ('Reddit users'). It distinguishes from siblings like 'search_reddit' (posts) and 'search_reddit_comments' by specifically targeting user profiles, and lists return fields (username, karma, account age, bio) for additional clarity.

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 vs alternatives (e.g., search_reddit for posts, search_reddit_comments for comments). The description implies usage for finding Reddit users but does not mention any conditions, exclusions, or preferred scenarios.

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

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

With no annotations, the description carries the full burden. It discloses the cost per request ('Billed $0.006 per request') and outlines the response contents, which is valuable behavioral context. It also mentions the optional sentiment analysis and its surcharge. It does not explicitly state read-only status or rate limits, but the 'Search' verb implies non-destructive behavior.

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

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

The description is concise: two sentences that front-load the purpose and return types, then add cost information. Every word earns its place, and there is no redundant filler.

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

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

With no output schema, the description adequately conveys the key return fields (text, author, engagement metrics, media, permalinks) and the optional sentiment enhancement. It covers cost and the optional parameter, but does not mention pagination, sorting, or date filters, which might be expected for a search tool. Overall, it is sufficient for basic usage understanding.

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 itself documents both parameters with full coverage (100%), so the description does not need to repeat parameter details. It adds marginal context by mentioning the sentiment surcharge, but does not elaborate on parameter syntax or formats beyond the schema. Baseline 3 is appropriate when the schema handles semantics.

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

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

The description clearly states the tool's purpose: 'Search Threads (Meta's Threads app) posts by keyword' and lists the specific types of returned data (text, author, engagement metrics, media, permalinks). This distinguishes it from sibling tools like search_threads_users, which focuses on users rather than posts.

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

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

The description gives explicit context for when to use the tool: when you need to search Threads posts by keyword. It does not explicitly mention alternatives or exclusions, but the context is clear enough that an agent can infer when to use it. A higher score would require naming alternate tools or scenarios to avoid.

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 must carry the burden. It discloses the return fields (username, full name, verification status, profile picture) and the per-request cost, but it does not mention result limits, pagination, or rate limits. These omissions leave some behavioral uncertainty.

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 tool's purpose. The first sentence states the action and resource, and the second adds valuable return fields and pricing. No wasted words.

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

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

For a simple one-parameter tool with no output schema, the description adequately covers purpose, return fields, and cost. It could be more complete by specifying result count or pagination, but these are not critical for a basic search operation.

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

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

The schema already fully describes the only parameter ('query' with max 500 characters), achieving 100% coverage. The description adds no additional semantic detail beyond the schema, so baseline 3 is appropriate.

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

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

The description uses a specific verb ('Search') and resource ('Threads users'), clarifying that it searches user profiles on Meta's Threads app. This distinguishes it from sibling tools like search_threads (likely posts) and other user search tools.

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

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

The description clearly indicates this tool is for keyword-based user search, which implies usage context. However, it does not explicitly state when not to use it or mention alternatives like threads_user_profile for exact-username lookups.

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 only states the core action and does not mention pagination, sorting, region filtering, or the sentiment analysis surcharge, all of which are relevant behavioral traits.

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

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

The description is a single sentence with no filler or redundant phrasing, making it concise and front-loaded with the essential 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?

Despite the schema covering parameters, the description provides no information about return format, pagination limits, or the sentiment surcharge. With no output schema and moderate complexity, the description is not complete enough for full agent understanding.

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

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

Schema description coverage is 100%, so the baseline is 3. The description adds little beyond the schema, only implicitly mapping 'keyword' to the query parameter, but it does not clarify any additional parameter semantics.

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

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

The description uses a specific verb 'search' with a clear resource 'TikTok videos' and qualifier 'by keyword', making it obvious what the tool does and distinguishing it from sibling tools like search_tiktok_users and tiktok_video_details.

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

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

The description implies usage for keyword-based TikTok video search but provides no explicit when-to-use or alternative guidance. It does not mention alternatives like search_instagram or search_twitter for other platforms, leaving the agent to infer context from the tool name.

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

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

With no annotations provided, the description must carry the full behavioral burden. It discloses the return fields and the search-by-keyword behavior, which is useful. However, it does not mention pagination behavior (though the pages parameter exists in schema), rate limits, or authentication requirements. The read-only nature is implied by 'search' but not explicitly stated.

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 consists of two short sentences that front-load the purpose and return information. There is no redundant or extraneous content, 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?

For a low-complexity search tool with 2 parameters (1 required), no output schema, and no annotations, the description covers the core purpose and return values. It is missing some minor details like pagination behavior and potential rate limits, but these are partially addressed by the schema (pages parameter). Overall, it is sufficiently complete for an agent to select and invoke the 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% for both query and pages parameters, so the schema fully documents them. The tool description does not add any parameter-specific meaning beyond what the schema already provides, such as syntax or formatting. Baseline 3 is appropriate.

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

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

The description clearly states 'Search TikTok users by keyword' with a specific verb and resource, and lists the return fields (username, bio, follower/following counts, likes, video count). This distinguishes it from sibling tools like search_tiktok (which likely searches videos) and tiktok_user_profile (which retrieves a single 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 for keyword-based discovery of TikTok users but does not explicitly state when to use this tool versus alternatives such as search_tiktok or tiktok_user_profile. There is no mention of exclusions or preferred scenarios, so guidance is 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 must disclose behavioral traits, but it only says 'Search Twitter/X posts.' It fails to mention authentication requirements, rate limits, pagination behavior, return format, or side effects like the sentiment analysis surcharge. This is a critical gap for a tool with optional paid features.

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

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

The description is a single sentence with no fluff, making it highly concise. However, it is extremely brief and provides minimal value beyond the tool's name, lacking details about pagination, sorting, or sentiment analysis. While it is not verbose, it may be too terse to be considered 'appropriately sized' for a tool of this 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 there is no output schema and no annotations, the description should explain what the tool returns and any significant behaviors. It only gives a high-level purpose and omits details like result structure, the impact of the 'pages' parameter, or the cost implication of 'get_sentiment'. This is incomplete for a tool with multiple parameters and a non-obvious paid feature.

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 provides complete descriptions for all 4 parameters (query, pages, sort_by, get_sentiment), achieving 100% schema_description_coverage. The description adds no additional parameter-level meaning, so the baseline score of 3 is appropriate; the schema itself handles the semantics well.

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

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

The description clearly states the tool searches Twitter/X posts, using a specific verb and resource that distinguishes it from search_tools for other platforms (e.g., search_instagram) and from Twitter-specific tools like twitter_tweet_details or twitter_user_tweets. However, it doesn't elaborate on the exact scope of 'posts' (e.g., all public posts, retweets) or the search capabilities beyond the name.

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

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

The description provides no guidance on when to use this tool versus alternatives such as twitter_trends, twitter_tweet_comments, or search_twitter_users. It neither states when it is appropriate nor mentions any exclusions or alternative tools, leaving the agent 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?

No annotations are provided, so the description carries the burden. It discloses return fields and the search nature, but does not mention pagination behavior, rate limits, auth requirements, or result ordering. Sufficient for a simple read-only search but lacks deeper 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?

Two sentences, front-loaded with a specific verb and resource. No unnecessary words. Each sentence contributes meaning, with the second outlining return data.

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

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

No output schema exists, so the description compensates by listing key return fields. With only two well-documented parameters and no annotations, this is adequately complete for a simple search tool. Could mention data freshness or limitations, but not critical.

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

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

Schema description coverage is 100%, with both query and pages having descriptions. The tool description adds no new parameter-level semantics but clarifies output, which helps infer query purpose. Baseline 3 is appropriate given full 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?

Clearly states 'Search Twitter/X users by keyword' with a specific resource and scope. Mentions return data (username, bio, follower counts, verification status), distinguishing it from sibling search_twitter which likely targets tweets and other platform user searches.

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?

Implied usage is clear: use this tool to find Twitter/X users by keyword. However, it does not explicitly contrast with search_twitter or provide when-not-to-use guidance. The context is unambiguous enough for an agent to select it for user searches.

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 the transparency burden. It discloses return fields (title, URL, snippet, source, domain) and supported targeting/filter options, giving a solid overview. However, it omits potential behavioral nuances like rate limits, blocking, or how the AI Overview affects results, so it is adequate but not highly transparent.

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

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

The description is three sentences, front-loaded with the primary action. Each sentence provides distinct value: what it does, what it returns, and what features it supports. No filler or redundancy.

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

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

Given there is no output schema, the description sufficiently explains return values by listing result fields. It covers core capabilities and parameter behavior. Minor gaps include lack of explicit pagination behavior beyond the schema's pages parameter and no detail on how the optional AI Overview is represented, but these are minor for a search tool.

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

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

Schema description coverage is 100%, so the baseline is 3. The description summarizes features (country/language targeting, time filters, city geo) but does not add new meaning beyond what the schema already documents. It adds no extra detail on parameter formats or edge cases, so it meets but does not exceed the baseline.

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 core function with a specific verb and resource: 'Search the web (Google organic results).' It distinguishes itself from sibling search tools by specifying 'Google organic results' and listing output fields, which differentiates it from platform-specific searches like search_reddit or search_news.

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

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

Usage guidance is implied rather than explicit. The description focuses on what the tool does and its features, but does not state when to use it over alternatives or provide exclusions. Context from sibling names helps, but the description itself lacks clear 'when to use vs when not to use' 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 the full burden of behavioral disclosure, but it only states the basic search action. It omits any mention of return format, pagination behavior, cost implications, or whether it supports filtering beyond what the schema implies, leaving significant behavioral uncertainty.

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

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

The description is a single sentence with no wasted words, but it is under-specified for the tool's complexity. It lacks information about parameters or return behavior, making it too sparse to be considered appropriately sized.

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 4 parameters, no output schema, and no annotations, the description is insufficient. It does not explain what results are returned, how the parameters affect search behavior, or any edge cases, leaving the agent with a superficial understanding.

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% coverage, with descriptions for all four parameters. The description adds no extra meaning beyond the schema, so the baseline of 3 applies—adequate but not enriching.

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 'Search YouTube videos' clearly identifies the verb 'search' and the resource 'YouTube videos', making the core purpose evident. However, it does not differentiate from sibling tools like 'search_youtube_channels' or 'youtube_video_details', so it lacks the specificity for a 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?

No guidance is provided on when to use this tool versus alternatives. The description does not mention any context, exclusions, or alternative tools, leaving the agent without direction on selecting this over other search tools.

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

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

With no annotations provided, the description carries the full burden of disclosing behavioral traits. It does state the return fields, which gives some insight into the output structure. However, it does not explicitly mention that the operation is read-only, any pagination behavior (beyond what the schema says via 'pages'), rate limits, or potential error conditions. The description is adequate but not rich in behavioral 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 extremely concise, consisting of two short sentences. The first sentence states the core function and the second lists the returned data. Every word serves a purpose, and the structure is front-loaded with the primary action. It is an efficient and clear description without any filler.

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

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

For a relatively simple search tool, the description is almost complete. It explains the purpose and the return fields, while the schema handles the parameters. There is no output schema, so the description's mention of return fields fills that gap. However, it lacks any mention of result ordering, default behavior, or explicit differences from sibling search tools, but these are not critical for a basic channel search.

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

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

The input schema already provides complete descriptions for both parameters (query and pages), so the description adds little extra meaning beyond what the schema conveys. It reinforces that 'query' is the keyword, but it does not elaborate on usage context or edge cases for the parameters. With 100% schema coverage, the baseline of 3 is appropriate.

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

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

The description clearly states the tool's function: 'Search YouTube channels by keyword' with a specific verb, resource, and method. It distinguishes from sibling tools by specifying 'channels' rather than videos or general web search, and it lists the key return fields (channel name, description, subscriber count, and thumbnail). This makes the purpose immediately obvious.

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 usage is implied by the description: use this when you need to discover YouTube channels based on a keyword. However, there is no explicit guidance on when not to use this tool or alternatives such as search_youtube (for videos) or youtube_channel_details (for a specific channel's details). The description provides a clear context but lacks explicit exclusions or alternative references.

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 the full burden. It adds value by disclosing the per-request cost ($0.006) and enumerating return fields (text, engagement metrics, media, timestamps, permalinks), but lacks details on pagination, post count limits, or error 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 long, front-loaded with the primary purpose, and includes return data and cost without any redundant fluff. Every word earns its place.

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

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

For a simple tool with two parameters and no output schema, the description covers core purpose, return fields, and pricing reasonably well. It lacks explicit post count or pagination details, but is adequate for most use cases.

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% for both parameters, including the get_sentiment surcharge note. The description adds no extra parameter-level information beyond what the schema already provides, so baseline 3 applies.

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

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

The description clearly states the tool retrieves a single Threads user's recent posts by username, with a specific verb ('Get') and resource scope. It distinguishes itself from sibling tools like threads_user_profile (which handles profiles) and search_threads (which searches across posts).

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

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

The description implies usage for fetching a specific user's posts but provides no explicit guidance on when to choose this over alternatives like threads_user_profile or search_threads. No exclusions or alternative tool mentions are given.

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

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

No annotations are provided, so the description must carry the burden of behavioral disclosure. It adds useful context by listing the returned data fields and the billing cost per request. However, it does not disclose potential rate limits, authentication requirements, or any error behavior. For a read-only profile fetch, the return-value list is helpful but incomplete for full behavioral 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 two sentences, front-loaded with the core purpose, followed by a concise list of return fields and the billing detail. Every sentence adds value without redundancy or fluff. It is highly scannable 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 simplicity (one parameter, no output schema), the description provides a complete enough overview: it states the purpose, the key return fields, and even billing cost. It does not explicitly note the absence of posts or recent activity, which could help distinguish from sibling tools, but that is a minor gap. The absence of an output schema is compensated by listing the main fields.

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 is fully described (coverage 100%), with 'username' having a clear description ('Threads username, with or without leading @'). The tool description adds minimal extra meaning beyond saying 'by username', which is already evident. Since the schema already provides strong semantics, the description neither enhances nor detracts significantly, earning the baseline score of 3.

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

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

The description uses a specific verb ('Get') and clearly identifies the resource ('full profile for a single Threads user by username'). It lists key return fields (biography, bio links, follower count, verification status), which distinguishes it from sibling tools like threads_user_posts or search_threads_users. The purpose is unambiguous and action-oriented.

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

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

The description clearly implies usage context: when you need a full profile for a specific Threads username. It does not explicitly state when not to use it or mention alternatives, but the phrasing 'single Threads user by username' inherently distinguishes it from search tools and post-focused tools. No exclusions are provided, but for a simple lookup this is adequate.

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 the full transparency burden. It clearly implies a read-only operation ('Get') and comprehensively lists the returned fields (bio, counts, verification, linked accounts), which goes beyond the schema. It also specifies the 'exactly one' input constraint. It does not disclose rate limits or error behavior, but this is a simple read operation and the description provides solid 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?

Three tight sentences: first states the action and identifiers, second enumerates the returned fields, third gives the exclusivity constraint. No filler or repetition. Every sentence adds value and the structure is front-loaded.

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

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

For a single-profile read with three params and no output schema, the description is nearly complete: it covers inputs and outputs. It lacks only explicit error handling (e.g., user not found, multiple identifiers supplied) and any caveats about nested data or pagination, but the given information is sufficient for most agent invocations.

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

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

The schema already covers 100% of parameters with good descriptions, so the baseline is 3. The description adds the crucial 'exactly one of username, user_id, or url' constraint, which is not captured in the schema's optional/required fields. This meaningful addition elevates the score to 4.

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 the full profile for a single TikTok user') and specifies the resource and input identifiers (username, user_id, or URL). It also lists the key fields returned, which distinguishes it from sibling tools like tiktok_video_details or search_tiktok_users.

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

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

The description gives clear context: use this tool when you need a full profile for one known TikTok user, and you can provide one of three identifiers. However, it does not explicitly contrast with search_tiktok_users (e.g., 'use search to find users first') or mention when not to use this tool, so it stops short of a 5.

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

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

With no annotations, the description carries the full burden. It clearly implies a read-only data-fetch operation and enumerates the specific data returned (caption, counts, URLs, cover images, music info, author details). It does not mention error cases like invalid IDs or what happens if both parameters are provided, but the core behavior is well disclosed.

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

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

The description is two sentences, front-loaded with the primary purpose, and every detail serves a purpose. No fluff 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 absence of an output schema, the description thoroughly covers return values by listing the data categories. It also addresses the parameter exclusivity and relates to a sibling tool. This is complete for a single-video lookup tool.

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

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

Schema coverage is 100%, so the schema already describes both parameters well. The description adds the crucial constraint 'Provide exactly one of url or video_id' and notes that video_id is 'as returned by search_tiktok', enriching the semantic meaning beyond the raw 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 gets full details for a single TikTok video, with specific verb and resource. It distinguishes itself from sibling tools like search_tiktok and tiktok_user_profile by focusing on single-video detail retrieval.

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

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

It explicitly instructs the agent to provide exactly one of url or video_id, which is key usage guidance. However, it doesn't explicitly name alternative tools for search or user profile cases, relying instead on the tool's clear single-video scope.

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 page size ('up to 20 posts per page'), cost ('billed $0.006 per page'), and the response contents (post text, engagement metrics, media, hashtags, reply status, permalinks). This adds meaningful behavioral context beyond the basic read operation.

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

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

The description is extremely concise, consisting of two sentences that front-load the purpose and then efficiently list returned data and operational details. Every sentence earns its place with no redundancy.

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

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

The tool is relatively simple with 3 parameters and no output schema. The description adequately covers what the tool returns, including specific fields and pagination/cost details. It could mention sorting order or authentication, but these are not critical given the scope.

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

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

All three parameters are already fully described in the schema, so the description does not need to cover them. It does add the per-page cost, which relates to the 'pages' parameter, providing useful operational context. However, this is a minor addition beyond the schema's existing 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 uses the specific verb 'Get' and identifies the exact resource: 'a single Truth Social user's recent posts (their feed) by username.' It clearly differentiates from sibling tools by naming the platform and scoping to a single user's feed.

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

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

The description does not provide any guidance on when to use this tool versus alternatives like search tools or other platform-specific user posts tools. It only states what it does, without exclusions or references to alternative tools for other 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?

No annotations are provided, so the description must carry the full burden of behavioral disclosure. It only states that trends are 'current' and tied to a location; it does not mention authentication needs, rate limits, response format, or what happens with an invalid woeid. This is a gap 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 two sentences long, with the core purpose in the first sentence and a practical usage tip in the second. Every word earns its place; there is no wasted text or redundancy.

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

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

For a single-parameter read-only tool with no output schema, the description provides enough to understand what the tool does and how to invoke it. It lacks details like pagination or response structure, but the low complexity means these are not critical. It is nearly complete, though not exhaustive.

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

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

The schema covers 100% of parameters and already documents woeid as 'Where On Earth ID for the location. Use 1 for Worldwide.' The description adds little beyond repeating the woeid hint. Since the schema does the heavy lifting, a baseline 3 is appropriate.

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

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

The description clearly states the action ('Get'), the resource ('current trending topics'), and the scope ('for a specific location on Twitter/X'). This distinguishes it from sibling tools like twitter_user_tweets or search_twitter, which serve different purposes.

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

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

The description gives clear usage context by explaining that it retrieves trending topics for a location and includes a practical hint ('Use woeid=1 for Worldwide'). However, it does not explicitly mention when not to use this tool or name alternatives, so it stops short of a 5.

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

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

No annotations are provided, so the description carries the full burden of behavioral disclosure. It does not mention pagination (pages parameter), the AI sentiment surcharge, rate limits, or any side effects. The single sentence reveals only 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 concise sentence that states the purpose without redundant wording. It is front-loaded and every word earns its place.

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

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

This is a simple get-comments tool, but there is no output schema and no annotations. The description does not mention response format, pagination behavior, or the sentiment analysis surcharge, leaving some gaps. However, the schema covers parameter details sufficiently, making it minimally adequate.

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

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

The input schema has 100% coverage with each parameter described (tweet_id, pages, get_sentiment). The description adds no extra semantic meaning, but the schema already provides clear parameter details, so a baseline score of 3 is appropriate.

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

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

The description 'Get the comments (replies) on a specific tweet' clearly states the action (get) and resource (comments on a specific tweet). It distinguishes from sibling tools like twitter_tweet_quotes and twitter_tweet_retweets by focusing specifically on replies/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 provides no guidance on when to use this tool versus alternatives such as twitter_user_replies (which retrieves replies made by a user). No exclusions or context are given beyond the basic purpose.

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 the transparency burden. The verb 'Get' implies a safe read operation, but it does not disclose potential limitations, auth needs, rate limits, or the sentiment analysis surcharge (though that is in the parameter schema). It is adequate but not rich.

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

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

Two short, information-dense sentences with front-loaded verb and resource. No filler or redundancy.

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

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

For a simple two-parameter read tool with no output schema, the description covers purpose, scope, and return content adequately. It could specify more about output structure, but 'full content' sufficiently conveys expectation.

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

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

Schema description coverage is 100% and both parameters have detailed descriptions. The tool description adds no additional parameter semantics, so the baseline of 3 is appropriate.

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

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

The description clearly states the tool gets detailed information for a single tweet by ID, and specifies the return contents (full content, engagement metrics, author info). This clearly distinguishes it from sibling tools like twitter_tweet_comments or twitter_user_tweets.

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 purpose implicitly indicates when to use (when detailed single-tweet info is needed), but it does not explicitly contrast with alternatives like twitter_tweet_comments or twitter_tweet_quotes. There are no exclusions or when-not-to-use 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?

No annotations are present, so the description must disclose behavioral traits. It only implies read-only behavior via 'Get' but does not mention pagination, potential rate limits, or that get_sentiment adds a surcharge. There is no information about side effects or required authentication.

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

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

The description is a single sentence of seven words, front-loaded with the core purpose and containing no filler. It is maximally concise and appropriately sized for a simple read operation.

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

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

The description is adequate for a basic get operation, but it lacks contextual details such as return format, pagination behavior, or the fact that quote tweets are typically returned as a list. Given the schema covers parameters and no output schema exists, it is minimally complete but not thorough.

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

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

The schema provides 100% coverage for all three parameters (tweet_id, pages, get_sentiment) with clear descriptions. The description adds no additional meaning beyond the schema, so the baseline of 3 applies.

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

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

The description clearly states the tool's function: 'Get the quote tweets for a specific tweet.' It uses a specific verb ('Get') and identifies the resource ('quote tweets') and scope ('for a specific tweet'), which distinguishes it from sibling tools like twitter_tweet_retweets and twitter_tweet_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 provides no guidance on when to use this tool versus alternatives, nor any exclusions or prerequisites. It is a bare statement with no contextual advice on selecting this tool among the many Twitter-related options.

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 only states the basic read operation and does not disclose pagination behavior, rate limits, authentication requirements, or any details about the output format beyond 'users'. This is minimal behavioral disclosure.

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

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

The description is a single, front-loaded sentence that conveys the essential purpose without any wasted words. It is appropriately concise for a straightforward read operation.

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

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

For a simple tool with two parameters, the description is sufficient to understand its core function. However, it lacks important context such as pagination behavior (though the pages parameter hints at it), return value structure, and any prerequisites or limits. The absence of an output schema increases the need for more detail, which is not provided.

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% for both parameters (tweet_id and pages), providing baseline value. The description does not add any further meaning to the parameters, merely restating that the tweet is specific. It neither enhances nor detracts from the schema.

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