Social Fetch

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

The annotations already declare readOnlyHint and openWorldHint, and the description adds no behavioral detail beyond that. It does not mention return format, pagination behavior, or any other runtime characteristics, so it contributes no transparency beyond the structured metadata.

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 filler or redundancy. It front-loads the core action and resource, 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 get-by-URL tool this is adequate, but the description does not explain what the returned storefront data looks like, whether pagination is involved, or how the many alias/ignored parameters should be treated. With no output schema and 18 parameters, a bit more context would help.

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

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

Schema description coverage is 100%, so the schema carries the parameter documentation burden. The description's 'by URL' aligns with the url parameter and its aliases, but adds no additional semantic value beyond what the schema already provides.

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

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

The description states a specific verb and resource: 'Get a creator Amazon Shop storefront by URL.' It clearly identifies what the tool operates on and how it is invoked. The title reinforces the same, and the 'creator storefront' qualifier distinguishes it from generic Amazon or shopping pages.

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 guidance on when to use this tool versus alternatives, no preconditions, and no exclusions. While 'by URL' implies the main input, it does not help an agent decide between this and similar retrieval tools in the large sibling set.

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

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

Annotations already declare readOnlyHint=true and openWorldHint=true, so the safety profile is covered. The description adds no extra behavioral context (e.g., no pagination, rate limits, or return format), but for a simple read-only get tool the minimal description is adequate. It does not contradict the annotations.

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

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

The description is a single, front-loaded sentence that conveys the essential action and inputs. Every word earns its place; there is no fluff or repetition.

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 schema contains 18 parameters, many of which are aliases or marked 'Ignored if this tool does not support it.' The description does nothing to help the agent navigate this noise or clarify that only albumId or url matter, nor does it describe the output or any preconditions. For a straightforward get tool, this is a notable gap given the schema clutter.

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 each parameter already has a description. The tool description merely restates that the album can be fetched by id or URL, which mirrors the existing schema descriptions for albumId and url. It adds no additional meaning beyond the schema, so the baseline 3 applies.

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

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

The description states a specific verb and resource ('Get an Apple Music album') and mentions the two key identifiers ('by id or album URL'). It implicitly distinguishes from sibling tools like appleMusic_artist_get and appleMusic_track_get by naming 'album', but does not explicitly name or contrast them.

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

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

No guidance is given about when to use this tool versus alternatives such as appleMusic_search_list for finding albums, or appleMusic_artist_get/appleMusic_track_get for other resource types. The description only states the input mechanism, not the selection criteria or exclusions.

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

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

The readOnlyHint and openWorldHint annotations already cover the safety profile, and 'Get' adds nothing beyond them. The description does not disclose behavior for invalid IDs, missing URLs, or the shape of the response, so it provides little behavioral value beyond structured fields.

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

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

A single 10-word sentence that front-loads the verb and resource with no filler. It is efficient and easy to parse, though the brevity leaves some behavioral and usage context unstated.

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 18 parameters and no output schema, this description is too thin. It does not describe the response contents, failure behavior, the relationship between artistId and url, or the unusual required parameters like conversation_id, which are left entirely to the schema.

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

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

Schema coverage is 100%, so the baseline is 3, but the description adds light value by highlighting the two meaningful parameters among 18: an artist id and an artist URL. It does not clarify precedence if both are supplied, but it does orient the agent toward the relevant inputs.

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

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

States a specific verb ('Get'), resource ('Apple Music artist'), and the input modes ('by id or artist URL'). The resource and platform are explicit enough to distinguish it from sibling tools like appleMusic_album_get, appleMusic_track_get, and spotify_artist_get.

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 id or artist URL' implies the calling condition: use this when an Apple Music artist identifier or URL is already available. However, it never explicitly names appleMusic_search_list as the alternative when only an artist name is known, so the guidance is only implicit.

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

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

Annotations already declare readOnlyHint and openWorldHint. The description adds 'Returns a list' and 'use cursor when paginated' — useful in principle, but the cursor instruction references a mechanism with no corresponding parameter in the input schema, so it is not actionable and could mislead an agent into inventing a cursor parameter.

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 with the core action front-loaded and no fluff. Slight deduction because the cursor guidance is vague and unsupported by the schema, which reduces the value of the second sentence.

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 13 parameters, the description is too minimal: it does not explain result item shape, pagination behavior, or default limits. 'Returns a list (use cursor when paginated)' is a thin substitute for the return-structure and paging guidance an agent needs.

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

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

Schema description coverage is 100%, so the schema carries the parameter documentation burden. The description adds no meaning beyond the schema's keyword-based search semantics; it does not clarify the many 'Ignored if this tool does not support it' parameters.

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

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

The description states a specific verb ('Search'), a clear resource ('the Apple Music catalog'), and the method ('by keyword'), plus the return shape ('Returns a list'). It differentiates cleanly from sibling get-by-id tools like appleMusic_album_get and appleMusic_track_get, and from other platforms' 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 never says when to prefer this tool over alternatives, mentions no exclusions, and names no sibling tools. Usage context is only implied by the tool name and 'Search' verb, not 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?

Annotations declare readOnlyHint=true, so the agent already knows this is a safe read operation. The description adds that identification can be by id or URL, but does not disclose behavior such as priority when both are given, error handling, or response format.

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

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

One sentence, no redundancy, and the core purpose is front-loaded. It is appropriately concise, though it could include more guidance 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 tool has 18 parameters including many aliases for url (link, path, tweetUrl, etc.) and utility parameters (trim, limit, offset, pageSize) that are marked ignored. The description gives no information about return values, which is necessary since there is no output schema. It also doesn't clarify whether to pass trackId or url when both are available. This leaves an agent without enough context for a correct call.

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

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

With 100% schema description coverage, all 18 parameters are already documented. The description names the two primary inputs (id and URL) but adds no meaning beyond the schema's descriptions, such as which alias to prefer.

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 an Apple Music track by id or track URL' specifies a clear action (get) and a specific resource (Apple Music track) with input criteria. However, it does not explicitly distinguish this from sibling tools like appleMusic_album_get or appleMusic_artist_get, relying on the tool name for that differentiation.

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

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

The description provides no guidance on when to use this tool versus alternatives such as appleMusic_search_list for finding tracks or appleMusic_album_get/artist_get. There is no mention of prerequisites, scenarios, or when not to use.

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

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

The read-only and open-world annotations already convey the safety profile, and the description adds that the returned account is scoped to the current session. It doesn't disclose behavior when no authentication is present or the exact shape of the account object, but no contradiction with annotations exists.

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

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

A single, well-formed sentence with no verbiage and the key action front-loaded. This is appropriately concise for a trivial whoami 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?

No output schema exists, so the description's mention of 'authenticated API account' is the agent's only handle on the return value. For such a simple tool this may prove suficient, but it leaves the exact response fields and edge cases (e.g., no session) implicit.

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 three parameters (context, llm_model, conversation_id) have detailed descriptions. The tool description itself contributes no additional parameter context, matching the baseline for a fully documented 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 names a specific verb and resource — 'get the authenticated API account' — and scopes it to the current session. This makes the tool's purpose unmistakable and clearly distinguishes it from the many platform-content getters in the sibling list.

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

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

No explicit instructions on when to use this tool or when to prefer a sibling are provided. Since no other tool in the sibling list handles authentication identity, the usage is reasonably implied by the name and description, but this falls short of explicit 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?

Annotations already declare readOnlyHint=true and openWorldHint=true, so the safety profile is covered. The description adds the useful context that this is for checking remaining credit before large metered operations, but it does not add further behavioral details such as whether the call itself consumes credit, how fresh the balance is, or how the result is structured.

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 one sentence, front-loaded with the core purpose, and contains no filler. Every word contributes to the tool's intent and usage timing.

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

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

For a simple read-only tool with full schema coverage, this is nearly complete: it states the purpose, when to call it, and implies the returned value is the remaining credit balance. The absence of an output schema means a slightly clearer statement of result format could help, but the tool's function is straightforward enough for an agent to use correctly.

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

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

Schema description coverage is 100%, and the schema already documents context, llm_model, and conversation_id thoroughly. The description adds no parameter-level meaning, which is acceptable given the baseline of 3 for high schema coverage.

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

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

The description uses a specific verb ('Get') and resource ('remaining credit balance'), and adds the relevant context of running before large batches of metered tools. It clearly distinguishes this from the many sibling get tools by focusing on billing/credit state.

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

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

It explicitly states when to use the tool: before running large batches of metered tools. There are no obvious sibling alternatives to exclude, so the lack of an explicit 'when not to use' is not a major 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?

Annotations already mark readOnlyHint=true and openWorldHint=true, so the safety contract is covered. The description adds minor scoping context ('single post by URL') but no information about response shape, errors, auth, or limitations beyond what annotations imply.

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

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

A single, front-loaded sentence captures the verb, object, and key input constraint with no wasted words. It is appropriately concise for a simple retrieval 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 read-only single-post fetch, the description plus full schema coverage supplies an agent with enough to select and call the tool. It lacks explicit return-format guidance because there is no output schema, but the operation is simple enough that this is a minor gap.

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 parameter meanings are fully documented in the schema. The description's 'by URL' simply reinforces the schema's url/alias fields without adding new semantics or clarifying how to supply the required context and llm_model fields.

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

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

Description uses specific verb 'Get' plus resource 'single Bluesky post' and input mode 'by URL,' which clearly differentiates it from list/feed siblings like bluesky_profile_posts_list and platform-specific post getters. The word 'single' removes ambiguity about paginated results.

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' gives clear context for when to invoke the tool: when the agent has a direct Bluesky post link and needs that one post. It does not explicitly name alternatives or exclusion cases, so it stops one point short of full 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?

Annotations declare readOnlyHint=true and openWorldHint=true, so the agent knows this is a safe read operation. The description adds that it accepts a handle with or without leading @ (via schema) but doesn't disclose behavior like rate limits, whether the profile includes counts/followers, or what happens for invalid handles. With annotations covering safety, a 3 is appropriate.

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 with no waste. The core action and input are front-loaded. It could add a bit more context about what the profile contains, but it is appropriately concise.

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

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

For a simple read-only profile lookup with annotations covering safety and 100% schema coverage, the description is mostly complete. However, it doesn't mention what fields the profile returns (followers, bio, etc.) or how to handle invalid handles, and there is no output schema. Given the large sibling list, a bit more differentiation would help.

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

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

Schema description coverage is 100%, so the schema already documents all parameters. The description adds minimal meaning beyond the schema: it identifies 'handle' as the key input. The many alias parameters (user, username, urls, etc.) are documented in the schema as aliases for handle, so the description doesn't need to repeat them. Baseline 3 is correct.

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

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

The description states a specific verb ('Get') and resource ('Bluesky profile') and clarifies it accepts a handle. It distinguishes from siblings like bluesky_post_get and bluesky_profile_posts_list by focusing on the profile entity, though it doesn't explicitly name those siblings.

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

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

The description implies usage: when you need a Bluesky profile and have a handle. It does not explicitly state when to prefer this over sibling tools like bluesky_profile_posts_list or how to handle missing handles. The schema's alias parameters provide some guidance (prefer handle), but the description itself offers no when-to-use or exclusions.

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

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

Annotations already declare readOnlyHint=true and openWorldHint=true, so the safety profile is covered. The description adds the pagination behavior ('use cursor when paginated') and the handle-based lookup, which is useful. However, it doesn't disclose details like rate limits, what happens with invalid handles, or the shape of the returned list. With annotations covering the read-only nature, a 3 is appropriate.

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 front-loads the core action and resource, then adds the pagination note. It is efficient and free of fluff. Slightly more detail on when to use it could be added, but the current structure is appropriately sized for a list 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?

For a read-only list tool with 100% schema coverage and no output schema, the description covers the essential behavior: what it lists, by what identifier, and how pagination works. However, with 19 parameters including many aliases and ignored fields, the description doesn't help the agent understand which parameters are actually meaningful (handle, cursor, userId) versus noise. The openWorldHint annotation suggests the tool may return unexpected data, but the description doesn't elaborate on that.

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

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

Schema description coverage is 100%, so the schema already documents all parameters. The description adds the semantic that 'handle' is the primary identifier and that cursor is used for pagination, which aligns with the schema. However, it doesn't clarify the many alias parameters (urls, user, username, etc.) beyond what the schema already says, nor does it explain ignored parameters like limit, offset, pageSize. Baseline 3 is correct since the schema carries the heavy lifting.

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

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

The description states a specific verb ('List'), resource ('posts from a Bluesky profile'), and the key identifier ('by handle'). It clearly distinguishes from siblings like bluesky_profile_get and bluesky_post_get, though it doesn't explicitly name them. The mention of pagination via cursor adds useful 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 implies the primary use case (listing posts by handle) and mentions pagination handling, but it does not explicitly state when to prefer this over alternatives like bluesky_profile_get or bluesky_post_get, nor does it mention exclusions or prerequisites. The context is clear enough for basic selection but lacks explicit routing 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?

Annotations already declare readOnlyHint=true and openWorldHint=false. The description adds useful behavioral context beyond these annotations: it explains what each mode returns (compact field digest vs. full page including Examples/SDK snippets) and specifies the accepted pathname patterns. It does not describe error handling or auth requirements, but the readOnly annotation already covers the safety profile and the description provides meaningful mode semantics.

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

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

Three sentences, each carrying essential information: the action and source, the mode behavior, and the accepted pathname formats. No filler or redundant restatement of the tool name.

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

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

Despite having no output schema, the description gives an adequate sense of the return format for both modes (compact field digest vs. full page with Examples). It clearly ties the required docsPathname to docs_search, documents mode variants, and the schema covers the remaining required params (context, llm_model) with precise instructions. An agent has enough 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?

Schema description coverage is 100%, so the schema already documents all five parameters thoroughly. The description adds minor value by explicitly tying docsPathname to docs_search and noting acceptable pathname prefixes, but this largely echoes the schema's own examples and the mode param description. Baseline 3 is appropriate.

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

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

The description clearly states the tool's function: read a corpus page using a docsPathname obtained from docs_search. It distinguishes itself from the sibling docs_search tool by specifying the read action, the accepted pathname families, and the mode options, leaving no ambiguity about what it 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 explains when to use the tool (after obtaining a pathname from docs_search) and provides specific guidance on choosing mode=outline versus mode=full for different content needs. It references docs_search as the source of the pathname, which implicitly guides the agent away from using docs_read without a prior search, though it doesn't explicitly state 'use docs_search when you don't have a pathname'.

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

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

Annotations already declare readOnlyHint=true and openWorldHint=false, so the safety profile is covered. The description adds useful routing context (docs_read defaults to outline, field-crosswalk path) but does not describe docs_search's own result behavior, ranking, or output format. There is no contradiction with annotations, so the score stays at a solid 3.

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

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

Two sentences with the main action front-loaded and no filler. The routing to docs_read and the specific field-crosswalk path are compact and each sentence earns its place.

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

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

For a read-only search tool, the description adequately covers when to use it, when not to use it, and a concrete crosswalk route. The schema fully documents all six parameters, including required context and llm_model. The only notable absence is a description of what a result looks like, which keeps this from a 5.

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 one domain-specific query example ('field crosswalk') but does not add meaning to the query or context parameters beyond what the schema already provides.

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

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

The description states a specific verb ('Search'), a concrete resource ('SocialFetch docs'), and a clear scope ('API/SDK questions'). It also distinguishes itself from the sibling docs_read by explicitly saying response-field lookups should use docs_read instead.

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 scopes when to use this tool (API/SDK questions) and gives explicit alternatives: 'For response fields use docs_read' and a specific recipe for cross-platform field naming ('search `field crosswalk` or read /product/ask-ai/field-crosswalk'). This leaves little to inference.

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

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

Annotations already declare readOnlyHint=true and openWorldHint=true, so the safety profile is covered. The description adds that the tool accepts either an archive id or a public URL and that trim/includeTranscript modify payload/transcript behavior, but it does not disclose what happens when both url and adId are provided, whether the ad must be from a specific region, or what the response contains. No contradiction with annotations.

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

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

The description is a single, front-loaded sentence that states the core action and the two accepted inputs. It is appropriately concise, though it could have added a sentence on when to use it without becoming bloated.

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-resource getter with readOnlyHint=true and openWorldHint=true, the description is mostly adequate. However, with 19 parameters and no output schema, an agent would benefit from knowing that url and adId are mutually exclusive alternatives, that most alias parameters are legacy, and what the returned ad object looks like. The description does not fully compensate for the noisy parameter list.

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

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

Schema description coverage is 100%, so the schema already documents every parameter. The description adds minimal semantic value beyond the schema: it clarifies that adId is the 'archive id' and that url is the 'public Ad Library URL', which slightly reinforces the schema. It does not explain the alias parameters (link, path, tweetId, etc.) beyond what the schema already says, nor the ignored parameters.

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

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

The description states a specific verb ('Get') and resource ('a single Facebook Ad Library ad') and identifies the two accepted identifiers (archive id or public URL). It is clear, though it doesn't explicitly distinguish itself from the sibling facebook_adLibrary_ads_search_get or the google/tiktok/linkedin adLibrary_ad_get variants; the name and 'single ad' wording do most of that work.

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: pass either an archive id or a public URL. It does not state when to prefer this over facebook_adLibrary_ads_search_get, nor does it mention that url/adId are alternatives or that one is required. No explicit exclusions or alternative routing 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?

Annotations already declare readOnlyHint=true and openWorldHint=true, so no safety disclosure is needed. The description adds beyond the annotations by revealing the return shape ('Returns a list') and the pagination contract ('use cursor when paginated'), both of which are useful for a tool with no output 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 with no filler, front-loading the action and then giving the most operationally important behavior (list result and cursor pagination). Every sentence adds value.

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

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

For a 22-parameter tool with no output schema, the description is lean but sufficient: it states the operation, the result type, and pagination, and the schema carries parameter detail. It could add a line about response fields, but that isn't necessary given the fully described schema and read-only annotations.

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

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

The schema covers all 22 parameters with descriptions, including enums and alias preferences, so parameter semantics are already well documented. The description's mention of 'keyword and filters' and 'cursor' aligns with the schema but adds little beyond it, matching the baseline for 100% schema coverage.

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

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

The description names a specific verb ('Search'), resource ('Facebook Ad Library ads'), and mechanism ('by keyword and filters'), making the core behavior clear. It doesn't explicitly distinguish itself from sibling tools like facebook_company_ads_list or facebook_adLibrary_ad_get, but 'Search' and 'keyword' signal the right category.

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

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

The description implies this tool is for keyword+filter searches and tells the caller to use a cursor when paginated, which is a thin usage context. It never states when to prefer it over sibling ad tools or any exclusions, so the 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?

Annotations already mark the tool as read-only and open-world. The description adds the useful behavioral note that results may be paginated and a cursor should be used. It does not disclose return format details or failure modes, but with annotations covering the safety profile, 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?

Two short sentences with no filler. The core action and resource are stated immediately, and the pagination instruction is a useful, non-redundant addition.

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 Synthesis attempted, so the description should explain what the returned list contains. It only says 'Returns a list' and mentions cursors, but does not describe fields, sorting, or how to interpret the results. The 12-parameter schema contains many generic/ignored fields, so the description could help by clarifying which parameters matter. It is acceptable but not complete.

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

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

The input schema already describes the primary 'query' parameter with a clear description (search query text for Facebook ad library companies). The description's mention of 'company name' aligns with the schema but adds little beyond it. Many other parameters are documented as 'Ignored if this tool does not support it', so the schema carries the semantic burden.

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'), the resource ('Facebook Ad Library companies / advertisers'), and the search method ('by name'). It distinguishes itself from sibling tools like facebook_adLibrary_ads_search_get by specifying companies/advertisers rather than ads.

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

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

The description gives clear context for when to use the tool: it accepts a company name and returns a paginated list. It does not explicitly name alternatives or exclusions, but the criteria are unambiguous and the pagination hint provides practical 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?

Annotations already declare readOnlyHint=true and openWorldHint=true, covering the read-only and external-data nature. The description adds the pagination behavior ('use cursor when paginated') and confirms it returns a list, which is useful but not extensive. Given the annotation coverage, this is acceptable but not outstanding.

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

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

The description is extremely concise, with three short sentences that front-load the purpose and immediately mention the two identifier options and pagination. There is no waste 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?

With 20 parameters but many generic ones, the description provides just enough to know the tool's core use, but it doesn't explicitly state that either pageId or companyName is required (only 'Accepts'), nor does it describe output fields beyond 'a list'. Since there is no output schema, some additional context about the response shape would be helpful, but the description is not severely lacking.

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 have descriptions. The description only reiterates that it accepts a page id or company name, which is already in the schema. It adds minimal value 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 clearly states the tool lists ads a company or Page runs in the Facebook Ad Library, with a specific verb and resource. It is distinct from broader search tools, but it doesn't explicitly differentiate itself from siblings like facebook_adLibrary_ads_search_get or google_company_ads_list, so a 4 is appropriate.

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

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

The description implies usage when you have a page ID or company name, but it doesn't explicitly state when not to use this tool or mention alternatives. The context of the name and the 'Accepts a page id or company name' hint provides only implied guidance, so a 3.

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

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

The annotations already declare readOnlyHint=true and openWorldHint=true, so the safety profile is covered. The description adds the lookup-method detail ('by URL or event id') but does not describe what fields are returned, whether the event must be public, or what happens when neither identifier is supplied.

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 filler or duplication of schema details. Every word earns its place and the key identifier options are stated immediately.

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-resource GET, the description is mostly sufficient, but the tool has 18 parameters, no output schema, and numerous aliases/ignored fields. It does not mention what the response contains, how to choose between `url` and `eventId` when both are present, or how this tool differs from the many Facebook 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%, so the schema already documents the parameters, including aliases and ignored fields. The description adds minimal meaning beyond reinforcing that `url` or `eventId` are the relevant identifiers, which maps directly to existing 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 identifies the verb ('Get'), the resource ('Facebook event'), and the two accepted lookup inputs ('URL or event id'). It clearly scopes this as a single-event lookup, though it does not explicitly distinguish it from sibling list/search tools like facebook_events_list or facebook_events_search_list.

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

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

The description implies when to use it: when you have a Facebook event URL or event ID. It gives no explicit guidance about when not to use it, nor does it point to alternatives such as facebook_events_search_list for discovery or facebook_events_list for listing.

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

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

The annotations already declare readOnlyHint and openWorldHint, so the description is not required to repeat that. It adds the pagination hint ('use cursor when paginated'), which is useful behavioral context beyond the structured data. It does not mention rate limits or auth, but given the annotations cover safety, this is sufficient.

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

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

The description is a single, well-structured sentence that front-loads the primary purpose and immediately states the return type and pagination behavior. Every word earns its place, 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 19 parameters and no output schema, the description is sparse but adequate for the core use case: it identifies the main input (URL) and the pagination mechanism. It does not explain the content of the returned list or any caveats about the explore URL, but given the schema fully covers parameters and annotations cover safety, it is minimally complete. More detail about the return structure would improve it, but it is not critically incomplete.

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

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

Schema description coverage is 100%, so the schema fully documents all parameters. The description adds no additional parameter semantics beyond what the schema already provides. It mentions the 'explore URL' but that is also in the schema. Thus, the description adds minimal value over the schema, 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 clearly states the verb 'List' and the resource 'Facebook events for a city by explore URL', which distinguishes it from siblings like facebook_events_search_list (search) and facebook_event_get (single event). The scope is explicit.

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 a city explore URL is available, but does not explicitly state when to use this versus alternative tools like facebook_events_search_list or facebook_profile_events_list. No exclusion criteria are given, so an agent must infer the appropriate context.

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

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

Annotations already declare readOnlyHint=true and openWorldHint=true, so the safety profile is covered. The description adds a pagination behavior ('use cursor when paginated') beyond the schema's cursor description, but it does not disclose whether the various 'Ignored if this tool does not support it' parameters are actually supported or any output details.

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

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

Two short sentences carry the essential action, resource, return type, and pagination guidance. There is no filler or redundancy; each sentence earns its place.

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

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

For a tool with 13 parameters and no output schema, the description is minimal: it states 'returns a list' but not the shape of list items, does not clarify which of the many limit/pagination aliases are honored, and does not route the agent among the multiple Facebook event tools. The rich schema compensates partially, but the description alone is only adequate.

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

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

Schema description coverage is 100%, so the baseline is 3 and the schema already explains query aliases, cursor, context, and llm_model. The description's 'by name' and pagination hint only restate what the schema already provides, adding no new parameter meaning.

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

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

The description states a specific action ('Search'), a resource ('Facebook events'), and a scoping qualifier ('by name'), and notes the output is a list. It does not explicitly contrast with siblings like facebook_events_list, so it stops short of full differentiation.

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

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

The search-by-name context implies when the tool is appropriate, and the pagination note is operationally useful. However, it never mentions alternatives such as facebook_events_list or facebook_event_get or states when not to use this tool, leaving the agent to infer selection among several Facebook event siblings.

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

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

Annotations already provide readOnlyHint and openWorldHint. The description adds no further behavioral context: no auth/visibility caveats, rate limits, failure behavior for invalid URLs or private groups, or return shape. Its 'by URL or group id' phrasing is more about input method than 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?

One front-loaded sentence with no filler. Every word contributes to identifying the resource and the lookup method.

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 18-parameter tool, the one-sentence description leaves return semantics unspecified and does not highlight that many parameters are aliases. However, the schema descriptions fully cover the aliases and required params, and the readOnly annotation covers safety, making it minimally adequate for a simple getter.

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 only echoes that url and groupId are accepted identifiers and adds no detail beyond the schema's own 'Alias for url. Prefer url.' guidance.

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

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

The description uses a specific verb ('Get'), names the resource ('Facebook group'), and states the two accepted lookup keys ('URL or group id'). This is enough to distinguish it from sibling 'facebook_group_posts_list', which targets posts rather than the group object itself.

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 guidance on when to choose this tool over alternatives such as facebook_group_posts_list, and no exclusions like public-only groups or prerequisites. The only usage signal is implicit from the verb and resource 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?

Annotations already declare readOnlyHint=true and openWorldHint=true, so the read-only safety profile is covered. The description adds a useful behavioral note beyond annotations — 'Returns a list (use cursor when paginated)' — which tells the agent the return shape and how to paginate. But it does not disclose auth requirements, rate limits, or response-size behavior, so the added value is moderate.

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

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

Two sentences with zero filler. The purpose is front-loaded in the first sentence, and the return/pagination note is packed efficiently into the second. 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 read-only list tool with a 100%-coverage schema, the description is adequate: it names the input and pagination mechanism. However, with 20 parameters including many 'Ignored if this tool does not support it' fields and forum-specific aliases, the description does not clarify which pagination/limit parameters actually function (e.g., limit, offset, maxResults), nor does it mention sorting via sortBy. No output schema means the 'Returns a list' note is valuable, but completeness is only middling.

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 surfacing the two meaningful parameters — group `url` as the primary input and `cursor` for pagination — but the schema already documents all parameters, including the noisy alias fields (tweetId, tweet_url, permalink) that the description does not help disambiguate.

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

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

The description states a specific verb and resource ('List posts from a Facebook group by group URL'), which is clear and inherently differentiates it from nearby siblings like facebook_profile_posts_list and facebook_events_list. However, it does not explicitly name or contrast any sibling, so an agent must infer the distinction from the word 'group'.

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 — nothing distinguishes it from facebook_profile_posts_list, facebook_events_list, or facebook_post_comments_list. No prerequisites (e.g., the group must be public, which the schema mentions but the description omits) or conditions are stated, leaving the agent to guess.

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

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

Annotations already declare readOnlyHint=true and openWorldHint=true, and the description is consistent with them. However, the description adds no behavioral context beyond that: no mention of return format, listing availability caveats, or any limitation of what 'details' includes.

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

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

A single, front-loaded sentence with zero waste. It is appropriately small for a simple getter, though the noisy 18-parameter schema might justify a second sentence clarifying the meaningful inputs.

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

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

Given the tool's complexity — 18 parameters, many irrelevant aliases, no output schema — the description is too thin. It implies the item URL is the input, yet both url and itemId are optional in the schema while context and llm_model are required, leaving the agent without guidance on how to actually 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 description coverage is 100%, so the baseline is 3. The phrase 'by item URL' confirms the url parameter as the primary entry point but adds little beyond the schema's own description. It does nothing to help the agent navigate the 18-parameter schema full of irrelevant aliases like tweetId and tweet_url.

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

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

The description states a specific verb and resource: 'Get details for a Facebook Marketplace listing by item URL.' This clearly distinguishes it from the marketplace search siblings (facebook_marketplace_search_list, facebook_marketplace_locations_search) by focusing on retrieving one specific item, though it doesn't explicitly name them.

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

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

No guidance is given on when to use this tool versus alternatives. It does not mention that facebook_marketplace_search_list should be used first to find items, nor does it call out the itemId alternative as the preferred path when the ID is already known. Context is implied only by 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?

Annotations already declare readOnlyHint=true and openWorldHint=true, covering the safety profile. The description adds useful context: it returns a list and mentions cursor-based pagination. However, the cursor note mildly conflicts with the schema's offset/limit parameters, creating ambiguity about actual pagination 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?

Two sentences with zero waste, front-loading the core purpose before the input/output details. Every clause earns its place.

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

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

The core function (location search returning coordinates) is clear and no output schema exists to carry the return-format burden. However, the pagination guidance ('use cursor') conflicts with the schema's offset/limit/pageSize parameters, and the description doesn't clarify which of the many noise parameters actually matter. This leaves ambiguity for a tool with 12 parameters.

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

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

Schema description coverage is 100%, so baseline is 3. The description adds the semantic that the query is a city or place name, which maps to the `query` parameter. But with 12 parameters including many noise aliases marked 'Ignored if this tool does not support it', the description does not help disambiguate which pagination parameters are active, which is a missed opportunity.

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

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

States a specific verb (search), resource (Facebook Marketplace locations), and the purpose (obtain coordinates for listing search). It clearly distinguishes from facebook_marketplace_search_list (listing search) and facebook_marketplace_item_get (single item), so an agent can tell it apart without opening schemas.

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

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

'To obtain coordinates for listing search' implies it is a prerequisite step before calling the listing search tool, but it never names the alternative sibling (facebook_marketplace_search_list) or states when not to use it. The usage context 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?

Annotations already declare readOnlyHint=true and openWorldHint=true, so the safety profile is covered. The description adds useful operational context beyond that: the result is a list and pagination is cursor-based, which matters for invoking the tool correctly on subsequent pages. It does not go into rate limits or auth, but the bar is appropriately lower with annotations present.

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 with no filler. The core operation and scope are front-loaded, and the pagination note earns its place as the only essential additional behavior to mention.

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 25 parameters, multiple aliases, required context/llm_model, and conversation_id sequencing, the description is minimal for the tool's complexity. It does not orient the agent toward the canonical parameters, required context, or output item shape, and there is no output schema to compensate. The cursor note is useful, but the overall picture is incomplete for such a complex tool.

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

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

Schema description coverage is 100%, so the schema already documents every parameter, including alias preferences (query over q, limit over count) and enum meanings. The description only adds the geospatial framing tying keyword and lat/lng together, which is helpful but stays at the baseline given the schema's thoroughness.

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

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

States a concrete operation ('Search Facebook Marketplace listings') and scopes it to keyword plus latitude/longitude, with the return shape described as a list using cursor pagination. This clearly distinguishes it from siblings like facebook_marketplace_item_get (single item) and facebook_marketplace_locations_search (location lookup).

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

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

The description implies the use case: search Marketplace listings by keyword near a location. However, it names no alternatives and gives no explicit direction on when not to use this tool, leaving the agent to infer distinctions from sibling names.

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

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

Annotations already declare readOnlyHint=true and openWorldHint=true, so the safety profile is covered. The description adds the pagination hint ('use cursor when paginated'), which is useful behavioral context beyond the schema. However, it doesn't disclose return format details or rate-limit behavior, which would be valuable for a list 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?

Two sentences, front-loaded with the core action and resource, and the pagination note is placed right after. No wasted words. Could arguably include a bit more context, but it's 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 read-only list tool with 100% schema coverage and no output schema, the description covers the essential invocation (URL, pagination). However, it doesn't mention the `feedbackId` optimization parameter or clarify which of the many alias parameters are preferred, which could lead to suboptimal calls. The openWorldHint annotation suggests the tool may behave dynamically, and the description doesn't elaborate on that.

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

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

Schema description coverage is 100%, so the schema already documents all 19 parameters. The description adds the key semantic that `url` is the primary input and that `cursor` is for pagination, but most parameters are aliases or 'ignored' flags that the schema already explains. The description doesn't add much beyond the schema's own 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 states a specific verb ('List') and resource ('comments on a Facebook post or Reel by URL'), which clearly distinguishes it from sibling tools like facebook_post_get or facebook_post_comments_replies_list. It doesn't explicitly name a sibling, but the resource+action is specific enough to differentiate.

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

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

The description implies usage context (when you need comments on a post/reel, provide the URL) but doesn't explicitly state when to use this vs alternatives like facebook_post_comments_replies_list or instagram_post_comments_list. The 'by URL' hint gives some guidance, but no exclusions or alternative routing.

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

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

Annotations already declare readOnlyHint=true, lowering the burden on the description. The description adds a modest behavioral fact: the tool returns a list and requires a cursor for pagination. It does not disclose ordering, empty-result behavior, or output shape, but for a read-only list tool with annotations this is reasonably 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 short and front-loaded with the main purpose, which is good. However, the incomplete and grammatically broken sentence 'Accepts a from post comments' is a structural flaw that prevents the description from being considered tightly written.

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?

Core facts about the resource, list return, and cursor-based pagination are present, and the annotations cover the read-only nature. Still, there is no output schema, the description does not explicitly explain how to obtain the initial repliesCursor from facebook_post_comments_list, and the garbled sentence leaves a gap that the schema must fill.

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

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

Schema description coverage is 100%, and the schema already gives meaningful detail for the key cursor parameter ('Comment repliesCursor from post comments, or page.nextCursor to paginate replies'). The description's mention of 'use cursor when paginated' mostly mirrors the schema, so it adds little beyond 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 opening sentence clearly specifies the operation and resource: 'List replies to a Facebook comment,' which distinguishes it from the sibling facebook_post_comments_list. However, the second sentence is malformed ('Accepts a from post comments') and never states what object is accepted, so the agent must rely on the schema to fully understand the intended input.

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 that the tool consumes a cursor originating from post comments and that pagination is handled via a cursor, but it does not explicitly state the prerequisite or name the sibling tool facebook_post_comments_list. There is no when-not-to-use guidance or mention of alternatives, so usage context is only implied.

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

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

Annotations already declare readOnlyHint=true and openWorldHint=true govern the safety profile. The description adds no behavioral context beyond 'Get'—no mention of return format, pagination, rate limits, or error behavior. With annotations present, the bar is lower, but the description contributes nothing extra.

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

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

A single, tightly written sentence with no redundancy. The essential information is present and 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?

Given the large number of parameters and no output schema, the description is too sparse. It doesn't explain what data the returned post/reel object contains, how reels differ from posts, or why context and llm_model are required. An agent would have to infer basic response behavior from the tool name alone.

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 19 parameters are already documented, including aliases and ignored parameters. The description only mentions 'by URL' and adds no semantic guidance on the required context or llm_model fields. Baseline 3 is appropriate since the schema carries the burden.

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 and resource: 'Get a Facebook post or Reel by URL.' This distinguishes it from list/search siblings that operate on profiles or searches. However, it doesn't specify what is included in the response (e.g., text, media, metadata), leaving some ambiguity about the scope of 'get'.

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 guidance on when to choose this tool over alternatives like facebook_post_comments_list or facebook_post_transcript_get. It doesn't mention any exclusions or preferred use cases.

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

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

Annotations declare readOnlyHint=true and openWorldHint=true, so the agent knows this is a safe read operation. The description adds the scope (post or Reel by URL) but doesn't disclose behavior like whether transcripts are auto-generated, whether they include timestamps, or what happens when no transcript exists. With annotations covering the safety profile, a 3 is appropriate – the description adds some context but not rich 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?

One sentence, zero waste, and the core resource (transcript) and input (URL) are front-loaded. It's appropriately sized for a simple retrieval tool. Could arguably add a note about supported content types, but the sentence is efficient and clear.

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

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

For a simple read-only retrieval tool with 100% schema coverage and readOnlyHint=true, the description is mostly adequate. However, it doesn't mention what the transcript output looks like (plain text? with timestamps?), whether it works for all Reels or only public ones, or edge cases like unavailable transcripts. The openWorldHint suggests the tool may return unexpected data, but the description doesn't prepare the agent for that.

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

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

Schema description coverage is 100%, so the schema already documents all parameters. The description adds the key semantic that `url` is the primary input and that aliases exist (link, path, tweetId, etc.) but the schema already says 'Alias for url. Prefer url.' The description doesn't add meaning beyond the schema's parameter descriptions, so baseline 3 is correct.

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

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

The description states a specific verb ('Get') and resource ('transcript for a Facebook post or Reel by URL'). It clearly distinguishes from siblings like facebook_post_get (which retrieves the post itself) and facebook_post_comments_list. However, it doesn't explicitly differentiate from the analogous transcript tools on other platforms (e.g., instagram_post_transcript_get), though the Facebook prefix in the name handles that.

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 a user wants a transcript of a Facebook post or Reel, provide the URL. It doesn't explicitly state when NOT to use it (e.g., for comments, use facebook_post_comments_list) or mention alternatives. The context is clear enough for a straightforward retrieval tool, but no exclusions or alternative routing 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?

Annotations already establish readOnlyHint=true and openWorldHint=true, so the description does not need to restate safety. It adds useful behavioral detail by noting that the tool 'Returns a list' and that callers should 'use cursor when paginated,' which goes beyond the annotations.

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

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

The description is three short sentences with no filler. It front-loads the core action, then gives the input requirement, and finally notes return/pagination behavior—each sentence earns its place.

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

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

For a read-only list tool with full schema coverage and no output schema, the description adequately covers the main input (profile/page URL) and the key runtime behavior (pagination via cursor). It does not discuss limit/offset semantics or alternative tools, but those are either in the schema or covered by usage guidance.

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

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

Schema description coverage is 100%, so the schema fully documents parameters like url, cursor, and the aliases. The description adds only minor semantic reinforcement by calling out URL as the key input and cursor for pagination, which does not significantly exceed what the schema already states.

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

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

The description states a specific verb and resource: 'List events hosted by a Facebook profile or Page.' This clearly distinguishes it from event-level tools like facebook_event_get, though it does not explicitly name sibling alternatives such as facebook_events_list or facebook_events_search_list.

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

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

The description gives a basic input requirement ('Accepts a profile or page URL') and mentions pagination, but it provides no explicit guidance on when to use this tool versus sibling alternatives, no exclusion criteria, and no mention of what scenario would call for a different events-list tool.

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

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

Annotations already declare readOnlyHint=true and openWorldHint=true, so the safety profile is covered. The description adds no additional behavioral context, such as return format, error handling, pagination, or rate limits. It simply restates the action without enriching the agent's understanding beyond the annotations.

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

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

The description is a single, direct sentence that is front-loaded with the action and resource. It is efficient and free of filler, though it is brief and omits the nuance of which parameter to use for a username. Still, it is appropriately concise for a simple get 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?

Given the tool's complexity (18 parameters, many aliases and ignored fields), the description is insufficient. It does not clarify that 'url' is the primary parameter, nor that most others are aliases or ignored. It also does not describe what the response contains. The agent would need to inspect the schema thoroughly to avoid misusing 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?

All 18 parameters have schema descriptions (100% coverage), so the schema already documents each field. The description mentions 'by URL or username' but does not map 'username' to any specific parameter; the schema only exposes 'url' and aliases. No additional meaning beyond the schema is provided, and the 'username' mention could cause confusion.

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 action ('Get') with a clear resource ('Facebook profile or Page') and an explicit input method ('by URL or username'). This clearly distinguishes it from sibling tools like facebook_profile_posts_list or facebook_profile_events_list, which retrieve specific content types rather than the profile itself.

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 any exclusions, conditions, or sibling tools. For example, it does not say 'Use this for basic profile info; for posts use facebook_profile_posts_list.' The usage context is only implied by 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?

Annotations already declare readOnlyHint=true and openWorldHint=true, so the safety profile is covered. The description adds valuable behavioral details: the credit cost structure (1 base, +2 per hosted asset with hostMedia=true), the 24/49 caps, and the fact that failed assets are not surcharged. This goes beyond the annotations and helps the agent anticipate cost and error handling.

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

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

Three sentences, each earning its place: purpose/input, credit model, and failure policy. The most important info is front-loaded, and there is no redundant or filler text.

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

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

For a simple read-list tool with full schema coverage, the description covers the essential purpose, input, and cost behavior. It does not explain pagination or output format, but the tool name and schema largely cover those. The ambiguity around 'up to 24 / 49 max' is a minor gap, so a 4 is appropriate.

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

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

Schema description coverage is 100%, so the schema already documents all 19 parameters. The description adds meaning to 'hostMedia' by explaining its credit impact and the hostedMedia delivery URLs, but it does not clarify the exact meaning of 'up to 24 / 49 max' or address other parameters like cursor or limit. 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?

The description states a specific verb ('List'), a clear resource ('photos from a Facebook profile or Page'), and the accepted input ('a profile or page URL'). It differentiates from sibling tools like facebook_profile_posts_list and facebook_profile_reels_list by specifying photos, so an agent can select it unambiguously.

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 (use when you need photos from a Facebook profile/page) and gives the URL requirement, but it does not explicitly state when to prefer this tool over siblings or mention alternatives like facebook_profile_get or facebook_profile_posts_list. The guidance is adequate but not explicit about exclusions.

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

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

Annotations already provide readOnlyHint=true and openWorldHint=true, so the safety profile is covered. The description adds a concrete cost model (1 base credit, +2 per hosted asset with caps, no charge for failed assets), which materially affects selection. It does not mention pagination or rate limits, but those are less critical given the read-only annotation.

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

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

The description is three short sentences that front-load the purpose, then cover input, then cost. Each sentence earns its place with no filler or repetition.

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

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

For a read-only list tool with 20 parameters, many marked as generic aliases or 'ignored if not supported', and no output schema, the description leaves gaps. It does not explain pagination via cursor, which parameters actually work (e.g., limit, offset), or what the response contains. The agent must rely on the schema for required parameters like context and llm_model, and even then some ambiguity remains.

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

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

The description adds meaning by explicitly saying it accepts a profile URL or page id (url/pageId) and by explaining the behavioral effect of hostMedia (credit surcharge). Most other parameters are generic aliases or 'Ignored if not supported' in the schema, and the description does not clarify which are honored. With 100% schema coverage on paper, the baseline is 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 states a specific verb ('List') and resource ('posts from a Facebook profile or Page'), which distinguishes it from siblings like facebook_group_posts_list and facebook_profile_photos_list. It also clarifies that both profiles and Pages are valid targets, and mentions accepting a URL or page id.

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 scopes the tool to Facebook profiles and Pages, implying that group posts are handled by a sibling. However, it does not explicitly name alternative tools or state exclusions (e.g., public vs private profiles). The credit note adds operational context for when to use the tool cost-effectively.

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

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

Annotations declare readOnlyHint=true and openWorldHint=true, so the safety profile is already known. The description adds valuable behavioral context beyond annotations: the credit cost structure (1 base, +2 per hosted asset up to 24/49 max), the fact that failed assets are not surcharged, and that hostMedia=true hosts media for 90 days and returns delivery URLs. This is meaningful operational transparency. It doesn't mention pagination behavior or rate limits, but the openWorldHint and readOnlyHint cover the main safety 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?

Three sentences with zero waste. The core action and input are front-loaded, followed by the credit cost detail and the failed-assets note. Every sentence earns its place. The cost information is compactly expressed and the 'up to 24 / 49 max' is precise.

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

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

For a read-only list tool with 100% schema coverage and no output schema, the description covers the essential operational details: what it lists, what input it accepts, and the cost implications of hostMedia. The main gap is that it doesn't describe the return format or pagination behavior, but since there's no output schema and the tool is a simple list operation, the description is largely complete. The cost transparency is a strong addition.

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

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

Schema description coverage is 100%, so the schema already documents all 19 parameters. The description adds meaning for hostMedia (explains the +2 credit surcharge and 90-day hosting) and url (accepts profile or page URL), which goes slightly beyond the schema. However, most parameters are aliases or 'ignored' fields that the schema already explains. Baseline 3 is appropriate since the schema does the heavy lifting and the description adds only marginal semantic value.

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

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

The description states a specific verb ('List'), a specific resource ('Reels from a Facebook profile or Page'), and the input form ('Accepts a profile or page URL'). It clearly distinguishes from siblings like facebook_profile_posts_list and facebook_profile_photos_list by naming the exact content type. The title reinforces the same, but the description adds the Page scope and URL input detail.

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

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

The description implies when to use it: when the user wants reels from a Facebook profile or Page, given a URL. It doesn't explicitly name alternatives or exclusions, but the sibling set makes the context clear (e.g., facebook_profile_posts_list for posts, instagram_profile_reels_list for Instagram). The credit/cost note also gives practical usage context. Missing explicit 'use X instead when...' guidance, so not a 5.

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

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

Annotations already communicate read-only, idempotent, open-world, and non-destructive behavior, so the description does not need to restate those. The description adds useful context about when to invoke the tool, but it does not disclose return format, rate limits, or other runtime behavior. No contradiction with the annotations.

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

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

A single front-loaded sentence conveys both the purpose and the usage threshold without filler. Every clause adds value, and the fallback clause is a meaningful decision heuristic for the agent.

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

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

For a meta-tool with rich parameter documentation and safe annotations, the description is largely complete: it tells the agent when to call and the schema tells it how. The lack of an output schema means return structure is not described, but 'additional tools' reasonably implies a list of tool definitions, so this is a minor gap rather than a blocking 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?

Schema description coverage is 100%, and the schema itself provides detailed guidance: llm_model is for analytics only and must not be guessed, and conversation_id must come from a prior server response without parallel calls until available. The tool description adds no parameter-specific meaning, so the baseline score 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 that the tool checks for additional tools and gives the trigger condition: when specialized capabilities might help. This immediately distinguishes it from the domain-specific getters and search tools among its siblings, which retrieve data rather than expand the available toolset.

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

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

It gives explicit when-to-use guidance: call it whenever a task might benefit from specialized capabilities, even if existing tools could work as a fallback. It does not list when-not-to-use cases, but for a discovery tool this is a clear and actionable usage rule.

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

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

Annotations declare readOnlyHint and openWorldHint, which the description does not contradict. It adds valuable behavioral context beyond the annotations: the one-month granularity and the fact that pagination is cursor-based. This is useful for the agent and goes beyond the structured metadata.

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 short sentences with zero fluff. Purpose is front-loaded, constraints are stated compactly, and every sentence earns its place. It's an example of minimal yet complete expression.

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 carries the burden of explaining the return format — it says 'Returns a list' and explains cursor pagination, which covers the key functional aspects. It could specify what the list contains (e.g., event types), but for a listing tool with clear annotations and sibling context, this is sufficient. A 4 reflects the minor gap in explicit output details.

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

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

Schema coverage is 100%, so the baseline is 3. The description adds meaning by clarifying that a username (handle) is required, that activity is returned one month per request, and that cursor is for pagination. This supplements the schema's bare parameter definitions without redundancy.

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

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

The description states a specific verb and resource — 'List recent public activity for a GitHub profile' — and adds precise constraints: one month per request and cursor-based pagination. This clearly distinguishes it from sibling tools like github_profile_repositories_list or github_profile_followers_list.

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

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

The description provides clear context on how the tool behaves — one month per request, cursor for pagination — but does not explicitly name alternatives or conditions for when to use this tool over its siblings. Context is clear, though exclusion criteria are absent, so a 4 rather than 5.

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

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

Annotations already mark the tool as read-only, and the description's 'get' aligns with that. It adds the year-scoping detail but nothing about output format, defaults, or rate limits; given the annotations, the description is acceptable but not rich.

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

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

The description is short and front-loaded, but the second sentence 'Accepts a username' is redundant with the title and schema. It is efficient overall, though not every sentence earns its place.

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

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

With 18 parameters and no output schema, the description is minimal. It identifies the core purpose but does not explain the return format or clarify which username alias to prefer (though the schema covers this). The read-only annotation and high schema coverage make it adequate, not complete.

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

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

Schema coverage is 100%, so the description need not repeat parameter details. The only parameter-related statement, 'Accepts a username,' adds no new meaning beyond the schema's handle and alias descriptions, keeping it at 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 names a specific resource ('contribution graph') and a specific action ('get'), scoped by GitHub profile and year. This clearly distinguishes it from siblings like github_profile_get or github_profile_activity_list.

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

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

The description implies the use case — retrieving a profile's contribution graph for a given year — but gives no explicit guidance on when to prefer this over related GitHub tools, nor any exclusions. An agent has to infer the context from the tool name and parameters.

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

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

Annotations already declare readOnlyHint=true and openWorldHint=true, so the read-only nature is known without the description. The description adds that the tool returns a list and supports cursor-based pagination, which is useful behavioral context beyond the annotations. It does not cover error behavior, rate limits, or filtering 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?

Three short sentences, front-loaded with the action, and no filler. Each sentence adds a distinct piece of information: what, input, and output/pagination behavior.

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

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

For a simple read-only listing tool with no output schema, the description provides the essential call contract (input, list response, cursor-based pagination). It lacks detail on result item shape and error conditions, but the annotations and schema cover safety and parameter basics, making it sufficient for calling.

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

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

Schema description coverage is 100%, so the schema fully documents parameters including handle and aliases. The description's mention of 'username' adds no semantic value beyond the schema, only reinforcing that handle is the primary input.

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

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

States a specific verb and resource ('List followers for a GitHub profile'), clearly distinguishing from sibling tools such as github_profile_following_list by the object ('followers'). However, it does not explicitly contrast itself with any sibling in the description.

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 choose this tool over alternatives like github_profile_following_list or tiktok_profile_followers_list. The usage is only implied by the tool name; no exclusions or context are provided.

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