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

Annotations already declare readOnlyHint=true, idempotentHint=true, and destructiveHint=false, covering the safety profile. The description adds value by specifying that it inspects the 'current' token and lists the details it reports (validity, expiration, scopes), which annotations do not convey. No contradictions.

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

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

Two sentences, no filler. The core function is front-loaded in the first sentence, and the use case completes 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 zero-parameter diagnostic tool with an output schema present and safety already disclosed via annotations, the description covers the purpose, the specific data inspected, and the common usage scenario. Nothing an agent needs to call it correctly is missing.

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

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

The input schema is empty with 100% coverage, so all parameters are already fully described (none exist). The description correctly makes no parameter claims, and the baseline of 4 applies for zero-parameter tools.

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 ('Check') with a concrete resource ('access token') and enumerates the exact aspects checked (validity, expiration, granted scopes). This distinguishes it from sibling tools like meta_health_check and the many get_* tools, which target business assets or system health rather than token 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?

The phrase 'Useful for diagnosing auth issues' provides clear context for when to invoke this tool. However, it does not explicitly name alternatives or state when not to use it, though the token-specific scope makes those exclusions largely implicit among the siblings.

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

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

Annotations already declare readOnlyHint, openWorldHint, idempotentHint, and non-destructive behavior, so the safety profile is covered. The description adds no behavioral context such as required permissions, rate limits, or error conditions, but it also 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 one concise sentence that front-loads the action and resource, then lists the relevant fields. Every word earns its place, with no redundant phrasing 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?

Given the simple one-parameter schema, rich safety annotations, and an output schema, the description is sufficient. An agent can correctly select and invoke this tool for a targeted account-details lookup without needing additional context.

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

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

The single parameter adAccountId is fully described in the schema, including an example format (act_123456789). The description adds no further parameter meaning beyond confirming the target is a specific ad account, so it provides no extra value here.

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

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

The description uses a specific verb and resource ('Get detailed information for a specific Meta ad account') and enumerates concrete data fields (name, currency, timezone, spend cap, status, business info). This clearly distinguishes it from sibling list-style tools like meta_list_ad_accounts.

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 'for a specific Meta ad account' phrasing implies a targeted single-account lookup, which is useful context versus listing tools. However, it does not explicitly state when to prefer this tool, what prerequisites exist, or how it relates to alternatives like meta_list_ad_accounts.

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, idempotentHint=true, and destructiveHint=false, so the safety profile is covered externally. The description adds endpoint and field context but does not disclose operational behavior such as pagination behavior, rate limits, or authentication requirements, leaving it at the baseline for annotation-backed tools.

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 sentence front-loads the verb, resource, endpoint, and expected fields with no filler or redundancy. Every word contributes to the agent's understanding.

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 endpoint, field list, complete parameter schema, and rich annotations give an agent enough to invoke the tool correctly. The main gap is a brief usage pointer or sibling distinction, which would make it fully complete given the large set of 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%, and the schema documents all five parameters with defaults, bounds, and formats, so the description does not need to add parameter detail. The mention of output fields like object, event, actor, timestamp, and extra_data is useful context but does not alter parameter semantics.

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

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

The description names a specific verb ('Read'), resource ('ad account activity logs'), endpoint path ('/{ad_account_id}/activities'), and expected output fields, so an agent can tell it apart from insight or asset tools. It does not explicitly name or contrast a sibling tool such as meta_get_insights_raw or meta_list_edge_raw, which keeps it just below the top score.

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

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

The phrase 'activity logs' implies an audit/event use case, but there is no explicit statement of when to prefer this tool over alternatives like meta_get_insights or meta_get_node_fields. No exclusions, prerequisites, or alternative tool names are provided.

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

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

Annotations already provide readOnlyHint, idempotentHint, openWorldHint, and destructiveHint=false. The description adds valuable behavioral detail by noting the response may contain an iframe body and that it never creates or edits a creative, which goes beyond the structured annotation 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?

One tightly worded sentence conveys the action, the object, the scope, and a key behavioral caveat. It is front-loaded with the core purpose and contains 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?

With a complete input schema, a comprehensive output schema, and strong annotations, the description covers all necessary aspects: what it does, the read-only nature, the format dimension, and the iframe body caveat. Nothing needed for correct invocation is missing.

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

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

Schema description coverage is 100%, so both adId and adFormat are already well documented in the schema. The description reinforces the role of the placement format ('requested placement format') but adds no new parameter-specific semantics beyond what the schema provides, matching 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 uses a specific verb ('Get') and a specific resource ('preview markup for an existing Meta ad'), and further narrows it to a requested placement format. It clearly distinguishes this tool from generic getters like meta_get_ads or meta_get_creatives by focusing on preview markup, not data records.

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

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

The description clearly positions the tool for fetching read-only preview markup of an existing ad, which is a distinct use case among the many getter siblings. It does not explicitly name alternative tools or state when not to use it, but the context is clear enough that an agent can infer its appropriate use.

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

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

Annotations already declare a read-only, idempotent, non-destructive operation, so the description does not need to restate safety. It adds some useful return-field context, but it does not disclose pagination behavior or the effective-vs-configured status nuance, which remain in the parameter schema rather than the description.

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

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

Two concise sentences with the core action front-loaded and no filler. The return summary is compact and complements, rather than duplicates, the schema and output schema.

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 rich annotations, a full schema with 100% parameter coverage, an output schema, and a clear description, the tool is largely complete for an agent to invoke effectively. It is only slightly incomplete in not providing explicit alternative routing or behavioral caveats beyond what structured fields already handle.

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 parameters like adSetId/adSetId aliasing plus statusFilter semantics are already documented. The description adds only the high-level notion of an optional ad-set filter, matching baseline value over the schema without going further.

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

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

The description names a specific verb ('List'), a clear resource ('ads'), a scope ('Meta ad account'), and an optional ad-set filter, making the tool's purpose immediately distinguishable from sibling tools like meta_get_campaigns and meta_get_adsets.

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 'List ads for a Meta ad account, optionally filtered by ad set' gives clear context for when the tool applies. It does not explicitly contrast alternatives such as meta_get_adsets or meta_get_ad_activity, nor does it state when not to use this 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, idempotentHint, and destructiveHint false, so the 'no mutation' statement is mostly redundant. The description adds useful scope detail about parent campaign budget/objective and account currency, but does not disclose additional behavioral traits such as error behavior, rate limits, or output caveats beyond what the annotations already cover.

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 dense, front-loaded sentence conveys purpose, scope, return type, and safety in around 20 words. There is no filler or repetition of schema details.

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

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

With only two fully documented required parameters, a complete annotation set, and an output schema present, the description supplies the remaining operational context an agent needs: this is a read-before-edit configuration lookup with native settings and no mutation.

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 explains both adSetId and adAccountId with usage guidance such as not substituting a campaign or business ID. The description itself adds no parameter-level meaning beyond the schema, so the baseline of 3 is appropriate.

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

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

The description names a concrete verb and resource: read an existing ad set plus its parent campaign budget/objective and account currency. It also clarifies the return nature with 'Returns native settings; no mutation,' making it distinct from broader list/read siblings like meta_get_adsets.

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 'before preparing an edit' gives a clear and specific context for when this tool is appropriate. It does not explicitly name alternatives or exclusions, but the intended use case is obvious enough for selecting this over sibling getters.

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, idempotentHint, and destructiveHint false, so the description does not need to restate safety. It adds some behavioral context by summarizing what kind of information is returned (targeting, budget, optimization, schedule), but it does not surface pagination or status-filter nuances beyond what the schema already exposes.

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 purpose first, then the optional filter, then the return value summary. Every clause earns its place with no repetition 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?

Given the full parameter schema, rich annotations, and an output schema, the description is largely sufficient for an agent to invoke the tool correctly. The main missing piece is guidance for distinguishing this tool from sibling listing tools such as meta_get_ads and meta_get_campaigns.

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 in detail. The description adds only that filtering by campaign is possible, which is already evident from the campaignId property. This meets the baseline but provides no extra 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 action ('List'), a clear resource ('ad sets for a Meta ad account'), and an optional filter ('by campaign'). It also previews the returned data categories. However, it does not explicitly differentiate this tool from siblings like meta_get_ads or meta_get_campaigns, so it stops short of a 5.

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

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

The description implies the tool is the one to use for listing ad sets and that campaignId can narrow results. It does not provide explicit when-to-use or when-not-to-use guidance, nor does it reference alternatives among the many sibling tools.

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

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

Annotations already declare readOnlyHint=true, idempotentHint=true, and destructiveHint=false, covering the safety profile. The description adds information about the output content ('Includes study type, status, and cells') but does not disclose behavioral traits like pagination, rate limits, or data freshness. Since annotations carry the main behavioral burden, the description provides modest additional value.

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

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

The description is a single, front-loaded sentence that states the primary action and scope immediately, followed by a brief note on included fields. No unnecessary words or redundancy.

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

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

For a simple list tool with one parameter and an output schema available, the description is sufficient. It states the purpose and what the result includes, without needing to explain return values since the output schema covers 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?

The schema covers the single parameter adAccountId with a clear description and example. The tool description adds nothing beyond that. With 100% schema coverage, the baseline is 3, and there is no reason to score higher.

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

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

The description clearly states a specific verb ('List') and resource ('conversion lift studies and A/B tests (Ad Studies)') with a scope ('for an ad account'). It adds detail on included fields (type, status, cells). However, it does not explicitly distinguish this tool from siblings like meta_get_study_results, which is a similar retrieval tool.

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

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

The purpose is clear enough that an agent can infer when to use it (when needing ad studies), but there is no explicit guidance on when not to use it or mention of alternative tools. It relies on the agent's ability to infer context from the purpose.

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

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

The description adds useful behavioral context beyond the readOnly and destructive annotations: it discloses pagination support and that rich fields depend on permissions. It avoids contradicting any annotation, and 'where permissions allow' helps set expectations about partial data.

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 compact sentence that front-loads the core purpose ('Read detailed ... audiences') and then adds two key behaviors (pagination, permission-dependent fields). Every word earns its place and there is no redundancy.

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

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

The schema fully documents parameters, annotations cover safety, and an output schema exists, so the description does not need to explain return values. It covers the essential scope, pagination, and permission nuance, but the lack of guidance on choosing this over meta_get_audiences leaves a slight completeness gap for an agent.

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

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

With 100% schema description coverage, the schema already documents all five parameters, including constraints and defaults. The description itself adds no parameter-specific meaning, so the baseline of 3 is appropriate; it has zero effect on parameter clarity.

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

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

The description clearly states it reads detailed custom, saved, and lookalike audiences, naming both the resource and action. It hints at being the detailed counterpart to other audience tools, but it does not explicitly differentiate from the sibling meta_get_audiences.

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 over alternatives such as meta_get_audiences. The description implies it serves detailed audience reads, but it does not state exclusions, prerequisites, or which sibling to prefer for simpler queries.

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, openWorldHint=true, idempotentHint=true, and destructiveHint=false, and the description's 'List' wording is consistent with those. The description adds no extra behavioral context like pagination limitations, rate limits, or the meaning of open-world results, but the annotations carry most of the safety burden.

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

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

The description is a single front-loaded sentence that directly states the verb, resource, and scope with zero filler. Every word contributes meaning, and the size is appropriate for this simple list-type tool.

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

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

Given the full parameter descriptions, complete output schema, and annotations covering read-only/idempotent behavior, the description is mostly sufficient. It could have pointed to meta_get_audience_details for single-audience lookups, but the core calling context is adequately covered by the schema and 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?

Schema description coverage is 100%, so all three parameters are already documented in the schema. The description's mention of custom/saved/lookalike mirrors the enum for 'type' and adds no new meaning beyond the schema; 'limit' and 'adAccountId' are fully covered by their schema descriptions.

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

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

The description uses the specific verb 'List' with the resource 'audiences' and names the three audience types (custom, saved, lookalike) plus the ad account scope. It clearly differentiates the list-level function from a detail-level tool like meta_get_audience_details, though it does not name that sibling explicitly.

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 siblings such as meta_get_audience_details or other audience-related tools. There are no alternatives named, no exclusions, and no context indicating when a user should choose a different 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 carry the behavioral burden with readOnlyHint, openWorldHint, idempotentHint, and destructiveHint, so the description adds modest context about data sources: ad account/ad set targeting and optional block-list edges. The verb 'Read' is consistent with annotations, and there is no contradiction, but no additional behavioral details such as permissions or rate limits are disclosed.

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

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

The description is a single front-loaded sentence with no filler: it starts with the verb 'Read', identifies the resource, and states the data source scope. Every phrase contributes meaningful selection information.

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

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

With all parameters documented in the schema, an output schema present, and annotations covering safety and mutability, the description is largely complete for an agent to invoke the tool. It conveys the read scope and optional block-list dimension, though it does not explicitly guide selection among sibling read 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 all 8 parameters with descriptions, types, defaults, and constraints. The description only broadly references block-list edges, matching includeBlockLists, but the schema handles parameter semantics adequately, so the baseline of 3 applies.

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

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

The description uses a specific verb and resource: 'Read brand safety, suitability, placement, and context-control signals from ad account/ad set targeting and optional block-list edges.' This is clearly distinct from the sibling tools, none of which mention brand safety or block-list controls.

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

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

The description implies use when brand safety, suitability, placement, or context-control signals are needed, and it names optional block-list edges as part of the scope. However, it does not provide explicit when-to-use vs. when-not-to-use guidance or name alternatives like meta_get_adset_configuration or meta_get_entity_configuration.

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, openWorldHint=true, idempotentHint=true, and destructiveHint=false, so the safety profile is clear. The description adds a permission-dependent availability caveat ('when permissions allow') and the notion of 'accessible' assets, which is useful context beyond the annotation flags.

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, tightly packed sentence that front-loads the key facts: read-only discovery, the asset categories, and the permission caveat. There is no filler or repetition of schema details.

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

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

Given the tool's complexity—six parameters, nested outputs, and pagination semantics—the description is minimal, but the input schema, annotations, and output schema carry most of the necessary detail. It is complete enough for an agent to understand the tool's core role, though it would be stronger with explicit guidance on pagination strategy and sibling-tool selection.

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 each of the six parameters already has rich semantic documentation including defaults, bounds, and contextual usage notes for cursor, cursors, businessId, and adAccountId. The description does not add parameter-level detail, so the baseline of 3 is appropriate.

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

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

The description uses a specific action ('Discover') and a concrete resource scope ('Meta Business assets') with the asset types enumerated: businesses, pages, Instagram accounts, pixels, and datasets. This makes the tool's purpose clear and distinguishes it from the more granular sibling getters, though it does not explicitly name or differentiate from 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 list of multiple asset types implies this is a broad discovery tool, but the description never states when to prefer it over sibling tools like meta_get_pages or meta_get_pixels, nor does it mention any exclusions. Usage context is only implicit through the 'assets' aggregation language.

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, idempotentHint=true, and destructiveHint=false, so the safety profile is covered. The description adds value by specifying the returned fields and the statusFilter nuance about native effective_status vs configured status. It does not mention pagination behavior beyond the cursor parameter, but the output schema and parameter descriptions cover much of that.

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

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

The description is a single, focused sentence that states the action, the resource, and the key output fields. It is front-loaded with the verb and resource, and every word earns its place. No fluff or repetition of schema details.

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

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

For a read-only list tool with a rich output schema and 100% parameter coverage, the description is nearly complete. It could be improved by explicitly noting pagination behavior or the relationship to sibling tools like meta_get_campaign_structure, but the annotations and schema cover the main operational needs.

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

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

Schema description coverage is 100%, so the schema already documents all four parameters. The description adds a small amount of context by listing the returned fields, which helps an agent understand what the output will contain. The statusFilter description in the schema is already rich, so the description itself doesn't need to repeat it.

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

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

The description states a specific verb ('List'), a resource ('campaigns for a Meta ad account'), and the key returned fields (ID, name, status, objective, budget, bid strategy). This clearly distinguishes it from sibling tools like meta_get_adsets, meta_get_ads, and meta_get_campaign_structure.

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 tool is for listing campaigns at the ad account level, and the statusFilter parameter description adds guidance on when to omit it ('Omit for post-creation verification and inspect both returned status fields'). However, it does not explicitly name alternatives or state when to prefer this over meta_get_campaign_structure or meta_get_insights.

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

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

Annotations already declare readOnlyHint=true, idempotentHint=true, and destructiveHint=false, covering the safety profile. The description adds value by disclosing the structural containment behavior of the response (campaigns contain ad sets contain ads) beyond what the annotations express.

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 purpose and hierarchy are front-loaded, and the usage context is provided in the second sentence without redundancy.

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

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

For a read-only, two-parameter tool with a full output schema, the description is sufficient. All required parameters are documented, annotations cover side effects, and the hierarchy explanation sets clear expectations. No critical behavioral information appears missing.

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

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

Schema description coverage is 100% and both parameters (adAccountId, campaignId) are well documented in the schema. The description adds no additional parameter-level semantics beyond the schema, so the baseline score of 3 applies.

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

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

The description identifies a specific verb ('Get'), a specific resource ('hierarchical campaign structure'), and defines the hierarchy as 'campaigns -> ad sets -> ads'. This clearly separates it from flat sibling tools like meta_get_campaigns, meta_get_adsets, and meta_get_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?

'Useful for understanding account organization' provides clear context for when to use this tool. However, it does not explicitly name alternative tools or state when not to use it, so it stops short of full exclusion 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, idempotentHint=true, and destructiveHint=false, and the description is fully consistent with them. It adds useful behavioral context beyond the annotations by warning that a successfully accepted batch can still contain per-item failures.

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 action and object, followed by a meaningful warning. No filler or repetition of schema details.

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

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

For a read-only, idempotent status-check tool with fully documented parameters and an output schema, the description covers the critical operational nuance (per-item failures may exist even after acceptance). Nothing essential is missing for correct invocation.

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

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

Schema description coverage is 100%, so the baseline is 3; the schema already explains the batch handle, catalog ID, and ad account ID. The description adds no additional parameter semantics beyond tying the whole operation to the batch handle.

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 ('Read'), a specific resource ('completion and per-item errors for a catalog batch handle'), and a key nuance that distinguishes it from catalog product queries: acceptance is not proof of success. This clearly sets it apart from sibling tools like meta_get_catalog_products.

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: it is for inspecting a catalog batch handle after submission, with the explicit warning to verify per-item results because batch acceptance alone is insufficient. It does not explicitly name alternatives or exclusions, but the usage context is unambiguous.

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

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

Annotations already cover the safety profile (readOnlyHint=true, destructiveHint=false, idempotentHint=true), and the 'without creating or updating' phrase largely restates that. The description does add value beyond annotations by disclosing an access prerequisite ('when catalog access is available' is a decision-relevant access condition) and the join-ready output framing, but it does not describe error behavior when access is unavailable or 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 no filler. The verb-resource-access condition is front-loaded in the opening sentence, and the second sentence earns its place by clarifying read-only scope and output intent. Every clause adds information.

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

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

Given the tool's complexity (8 params, multiple invocation modes, dependency on access), the description plus a full output schema and rich per-parameter schema descriptions cover most of what an agent needs. The only notable gap is behavior when catalog access is unavailable, which is relevant for error handling and is not addressed.

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

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

Schema description coverage is 100%, with each of the 8 parameters already documented (defaults, bounds, filters, and endpoint distinctions like batch IDs vs discovery via businessId). The description adds no parameter-level detail, so it correctly relies on the schema baseline rather than compensating for any missing parameter semantics.

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

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

The description states a specific verb ('Read') with a specific resource ('Product Catalogs and Product Items') and a scope condition ('when catalog access is available'). It also differentiates the tool from any mutation workflow by explicitly saying it does not create or update catalog assets, which separates it from sibling tools like meta_get_catalog_batch_status.

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

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

The description gives clear context: use this for read-only product metadata when catalog access exists, and the 'join-ready' phrasing signals a primary use case (feeding join operations with product insights). However, it does not explicitly name an alternative for scenarios where catalog access is missing or when mutations are needed, so it falls short of full exclusionary 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, openWorldHint, idempotentHint, and destructiveHint=false, so the description only needs to add value beyond those. It does so by describing the enrichment behavior: real ad names, collection covers, all carousel/flexible components, resolved hashes and video URLs, plus the separate classification of catalog-only ads. 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?

Three dense, front-loaded sentences with no filler. Every clause adds information: what is returned, how catalog-only ads are handled, where to go for an interactive gallery, and what remains available for diagnostics.

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 enrichment tool with complete schema documentation, existing annotations, and an output schema, this description is sufficient. It clarifies the value-add output, the catalog-only edge case, and the escape hatch for raw diagnostics or interactive browsing, leaving no critical selection or invocation 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 the baseline is 3 even though the description itself adds no parameter-specific detail. The description's 'ad-linked' phrasing implies the identifier parameters, but all syntax, defaults, bounds, and selection behavior are already carried by the schema.

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

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

The description opens with a specific verb and resource ('Return ad-linked creative media') and enumerates concrete outputs: actual ad names, collection covers, carousel/flexible components, resolved image hashes, and video URLs. It also signals boundary cases (catalog-only ads) and distinguishes its enriched output from raw creative metadata.

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 this tool is appropriate: resolving ad-linked creative media with enriched human-readable assets. It also provides a when-not signal by routing interactive visual gallery needs to GetMCPAds and noting raw metadata remains available for diagnostics. It does not explicitly name the sibling meta_get_creatives as the raw-metadata alternative, so the guidance is slightly below fully 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, idempotentHint, and destructiveHint=false, so the safety profile is covered. The description adds that it returns creative details and lists content categories, but does not disclose behavior beyond that, such as pagination or how optional adIds affects results. No contradiction with annotations.

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

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

Two short sentences, no filler. The main verb and resource are front-loaded, and the content-type list 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, simple 3-parameter tool with a full schema and output schema, the description is adequate. It could be more complete by noting that adIds is optional and specifying what happens when it is omitted, but nothing critical is missing for correct invocation.

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

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

Schema description coverage is 100%: adAccountId, adIds, and limit all have meaningful schema descriptions. The tool description adds no semantic detail 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 uses a specific verb and resource ('Get ad creative content') and enumerates content types returned (text, images, videos, links, call-to-action), so an agent can tell what the tool does. It does not explicitly distinguish this from sibling meta_get_creative_assets, so it stops short of 5.

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

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

There is no guidance about when to reach for this tool versus alternatives such as meta_get_creative_assets, meta_list_ad_images, or meta_list_ad_videos. The phrase 'for specified ads' implies a use case, but no exclusions, prerequisites, or sibling routing are offered.

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?

Beyond the readOnly, openWorld, and idempotent annotations, it adds that data is aggregated across levels and that diagnostics depend on status/effective_status/issues_info 'where available.' This communicates partial data availability and non-raw aggregation behavior. It does not contradict annotations.

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

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

A single front-loaded sentence with no filler, starting with the key verb and scope. The later clause is dense but acceptable; it could be split for readability without changing substance.

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 full parameter descriptions, an output schema, and safety annotations, the remaining burden is selection context, which the 'delivery diagnostics' scope mostly covers. It could add explicit alternatives or caveats about pagination and data availability, but schema and annotations already carry much of the load.

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 seven parameters. The description adds light context by mapping 'status/effective_status/issues_info' to diagnostic fields and 'simple delivery insights' to date/time filtering, but it does not materially extend schema semantics.

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

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

States a specific verb ('aggregate') and resource ('delivery diagnostics') with explicit scope across campaigns, ad sets, and ads. The phrase 'delivery diagnostics' clearly differentiates it from sibling reporting tools like meta_get_insights or meta_health_check.

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 tool is for read-only delivery health aggregation but gives no explicit when-to-use or when-not-to-use guidance. It does not name alternatives or selection conditions, so an agent must infer usage from the phrase 'delivery diagnostics.'

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 cover read-only, idempotent, open-world, and non-destructive behavior, so the bar for additional value is lower. The description adds meaningful context beyond annotations: 'never creates, changes or retries the entity' and the caveat that missing or normalized fields must be inspected before claiming an exact match. This helps an agent understand result reliability without contradicting 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?

Two sentences, front-loaded with the core action and read-only guarantee, followed by the reconciliation caveat. Every sentence earns its place and there is no redundant restatement of the title or schema.

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 a fully described input schema, an output schema, and annotations covering safety and open-world behavior, the description is complete enough. It supplies the reconciliation purpose and the critical caveat about missing/normalized fields, which are the only non-obvious details an agent needs to use 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 input schema fully explains adAccountId, entityId, and fields. The description adds little per-parameter meaning, though it reinforces that fields are read during reconciliation and that normalized/missing values are possible. Baseline 3 is appropriate because the schema carries the param-semantics load.

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 ('Read'), a resource ('a specific entity in its ad account'), and a purpose ('reconciliation'), which clearly conveys what the tool does. It differentiates itself from the many list/get siblings by focusing on a single entity by ID and fields, though it does not explicitly name an alternative to distinguish from.

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

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

The description implies usage for reconciliation and explicitly warns against expecting mutation or retries, but it does not state when to prefer this tool over siblings like meta_get_campaigns or meta_get_adset_configuration. There is no explicit when-to-use/when-not-to-use guidance or mention of alternatives, leaving selection partly 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, idempotentHint=true, and destructiveHint=false, so the safety profile is covered. The description adds valuable behavioral context beyond annotations: the query planner automatically splits incompatible metric/breakdown combinations into multiple API requests and merges results. This is a significant behavioral trait that an agent must know to understand response shape and performance. It doesn't mention pagination or rate limits, but the schema's limit parameter already covers pagination bounds.

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 purpose is front-loaded, the resource pointers are concise, and the key behavioral trait (automatic splitting/merging) is stated last but is the most important non-obvious detail. 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?

For a complex tool with 13 parameters, nested objects, and an output schema, the description is reasonably complete. It covers the core purpose, available metrics/breakdowns, and the automatic query planning behavior. The output schema exists, so return values don't need explanation. The only minor gap is not explicitly mentioning pagination behavior beyond the limit parameter, but the schema's limit description already covers 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 13 parameters thoroughly. The description adds the crucial context that metrics come from meta://metrics and breakdowns from meta://breakdowns, which is genuinely useful. However, it doesn't add much beyond that because the schema already explains each parameter's meaning, defaults, and constraints. Baseline 3 is appropriate when the schema does the heavy lifting.

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

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

The description clearly states the tool queries Meta Ads performance insights, lists supported metrics/breakdowns, and distinguishes itself from siblings like meta_get_insights_raw by mentioning intelligent query planning and automatic splitting of incompatible combinations. The verb 'Query' plus the resource 'Meta Ads performance insights' is specific and unambiguous.

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

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

The description provides clear context for when to use this tool (querying performance insights with metrics/breakdowns) and points to meta://metrics and meta://breakdowns resources for available values. It doesn't explicitly state when NOT to use it versus alternatives like meta_get_insights_raw, but the mention of automatic query planning and merging implies this is the higher-level, more convenient option. A clear exclusion of raw access would have made this 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 declare readOnlyHint=true, idempotentHint=true, destructiveHint=false, and openWorldHint=true, so the safety profile is fully covered by structured data. The description adds a small behavioral note about using 'validated native field names' and mentions pagination, but it does not disclose significant additional traits such as rate-limit implications, error behavior on invalid fields, or that the openWorldHint means the tool may accept unknown native fields. Given the strong annotation coverage, the description provides only marginal extra value beyond what annotations already state, so 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 exactly two sentences. The first sentence front-loads the core action and all major parameter categories, and the second sentence provides the crucial sibling-context. Zero filler or redundant restatement of the tool name. Every word earns its place and the structure leads with the most important information.

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

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

Given the tool's complexity (14 parameters, nested objects, output schema present), the description is complete enough for an agent to decide whether to invoke it and what to expect in general. The output schema exists, so return-value documentation is not required from the description. The description covers purpose, scope, and the key differentiator from the curated tool. However, for such a complex raw API tool, a slightly richer note on how pagination works or how open-world field names are handled might improve completeness, but the schema and annotations already fill most gaps.

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

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

Schema description coverage is 100% — every parameter has a meaningful description in the schema itself (e.g., fields: 'Native Meta Insights API fields; calculated aliases are not accepted here'; limit has bounds and default). The tool description only lists parameter categories ('breakdowns, action breakdowns, attribution windows, filters, sort, summary, and pagination') without adding specific semantics beyond what the schema already provides. Per the rubric, when schema coverage is high, the baseline is 3, and the description does not significantly raise it.

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

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

The description uses a specific verb ('Query') with a specific resource ('Meta Insights edge'), and enumerates the exact capabilities (native field names, breakdowns, filters, sort, summary, pagination). It also names the sibling tool meta_get_insights and draws a clear distinction: this tool is the raw-native-field counterpart to the curated metric catalog. An agent can immediately tell what this tool does and how it differs from the closest sibling.

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 an explicit use case: 'complements meta_get_insights when Meta adds fields before the curated metric catalog is updated.' This clearly identifies when to prefer this tool and names the alternative. However, it does not explicitly state when NOT to use this tool (e.g., 'if you need curated metrics, use meta_get_insights'), leaving the 'when-not' implicit rather than explicit. Also, no mention of other potential siblings like meta_list_edge_raw, though that is not necessary for a 4.

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

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

Annotations already declare readOnlyHint=true, idempotentHint=true, and destructiveHint=false, covering the safety profile. The description adds the permission caveat ('when permissions allow') and clarifies the sources of the data, which is beyond the annotations. However, it does not disclose pagination behavior or error handling, though the output schema and cursor parameter imply pagination. Given the annotations cover the main behavioral aspects, 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 with no redundant words. It front-loads the verb and resource, and the scope is stated efficiently. Every word earns its place, making it an exemplar of conciseness.

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

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

For a read-only list tool with 5 optional parameters and an output schema, the description covers the core purpose and the three source contexts. It does not explain whether parameters are mutually exclusive or if multiple can be used together, but the schema and output schema likely fill that gap. The permission caveat is a useful nuance. Overall, it is complete enough for an agent to invoke correctly without ambiguity.

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

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

Schema coverage is 100% with each parameter already described in detail. The description adds context by naming the three possible source types (Pages, Business Manager, ad account) that map to pageId, businessId, and adAccountId, but it does not introduce new information about limit or cursor. Since the schema carries the full parameter documentation, the description adds marginal value beyond it, aligning with the baseline 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 clearly states a specific verb ('List'), a specific resource ('Instagram accounts'), and the scope ('linked to accessible Pages, Business Manager assets, or an ad account'). This distinguishes it from siblings like meta_get_pages (pages only) or meta_get_business_assets (assets) by focusing on Instagram accounts as the output.

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 on when to use this tool: when you need Instagram accounts linked to Pages, Business Manager assets, or an ad account. It does not explicitly name alternatives or exclusions, but the specificity of the resource makes the use case evident, especially given sibling tools like meta_get_pages and meta_list_ad_accounts.

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, openWorldHint, idempotentHint, and non-destructive behavior, and the description's 'GET-only' phrasing aligns with these rather than adding new information. It does add context around the 'escape hatch' purpose and the flat-fields limitation, but much of that is also present in the schema's parameter descriptions, so the net added behavioral insight is modest.

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

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

The description is two tight sentences with zero fluff. The core action is front-loaded, and the second sentence explains the tool's raison d'être without digressing. Every sentence earns its place, making it efficient 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 read-only, idempotent tool with full schema coverage and an output schema, the description supplies the essential context — it is a fast-moving escape hatch for fields not yet in the fixed schema. It does not explain return value details, but the output schema covers that, and the annotations already cover safety. It is nearly complete for an agent to decide when and how to invoke it.

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

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

Schema description coverage is 100%, so each parameter (nodeId, fields, includeMetadata) is already well documented in the input schema. The description reinforces the notion of 'arbitrary flat fields' for the fields parameter, but it does not add substantive semantic detail beyond what the schema already provides, so a baseline score of 3 is appropriate.

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

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

The description states a clear action ('Read arbitrary flat fields') on a specific resource ('one Meta Graph node'), and directly distinguishes itself from sibling tools by framing itself as an 'escape hatch' for newly released fields that fixed schema tools may not yet cover. This makes the tool's unique role immediately obvious.

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

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

The description implies when to use this tool — when you need fields that are 'newly released' and not yet in the fixed MCP schema. It provides this context clearly, but it does not explicitly name the alternative specific tools (e.g., meta_get_campaigns) or state when not to use the escape hatch, leaving the exclusion to inference rather than 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, openWorldHint, idempotentHint, and non-destructive behavior. The description adds a meaningful caveat that results are content insights and must not be interpreted as organic-only, which goes beyond the annotations. However, it does not mention provider permission requirements for insights or pagination behavior, though those are partly covered by the schema and annotations.

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

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

The description is two sentences with no filler. The main action and scope are front-loaded, and the caveat is placed second. Every word earns its place, making it an exemplary concise definition.

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

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

The description gives a clear purpose and a key caveat, and the schema plus output schema are detailed. However, with 11 optional parameters and no required fields, an agent may need more guidance on which parameter combinations to use or when to apply this tool relative to the many similar getters. It is adequate but not comprehensive.

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

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

Schema description coverage is 100%, so all 11 parameters are already thoroughly documented. The description only summarizes the resource types and mentions 'optional insights', which maps to includeInsights, but adds no additional meaning beyond the schema. Baseline 3 is correct when the schema does the heavy lifting.

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

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

The description states a clear verb ('Read'), specific resources (Facebook Page posts, Instagram media), and the enrichments (URLs, native periods, optional insights). It explicitly distinguishes these as 'content insights, not Ads Insights', which differentiates it from advertising-focused 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?

There is no explicit when-to-use guidance or reference to alternative tools. The only comparative statement is a caution about not inferring an organic-only breakdown, which is interpretive rather than a routing instruction. With 40+ sibling tools, an agent receives no direction on when to choose this over meta_get_page_posts or meta_get_insights.

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

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

Annotations already declare readOnly, idempotent, openWorld, and non-destructive behavior. The description adds meaningful context on top: it resolves a Page token from the connected user, returns only core post fields, and explicitly notes that no advertising eligibility is established. No contradiction exists, and the added behavioral context is valuable.

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

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

The description is compact and front-loaded: the core read action appears first, followed by return contents, then the key parameter use case, then scoping exclusions. Every sentence contributes information without 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 read-only paginated tool with a fully documented input schema and output schema, the description covers the functional purpose, token resolution, return fields, parameter-specific behavior, and exclusions. Nothing an agent needs to correctly select and call this tool is missing.

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

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

Schema description coverage is 100%, so the baseline is 3. The description adds beyond the schema by explaining that postId switches the call from the recent-post list to an exact existing post and ties it to the ad preflight scenario. This semantic clarity goes beyond the raw schema field definitions.

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

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

The description uses a specific verb-resource pair ('Read published Facebook Page posts') and clearly delimits its scope by stating what it returns (PageID_PostID, message, permalink, media attachments) and what it does not request (Instagram media, comments, likes, insights). This distinguishes it from the many sibling tools focused on insights, ad accounts, or creative assets.

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 an explicit use case ('Use postId for an exact existing-post ad preflight') and clarifies that this read alone does not establish advertising eligibility, setting expectations about what the tool can and cannot accomplish. It does not explicitly name alternative sibling tools for insights or other data, but the exclusions are sufficient for practical 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, idempotentHint=true, and destructiveHint=false, so the safety profile is covered. The description adds useful scope information ('accessible' pages) and notes Instagram account references are included 'when available', but it does not add extensive behavioral context beyond that.

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 action and resource first, followed by a compact field list. It contains no filler and does not repeat schema or annotation information.

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

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

The structured metadata is rich: full parameter descriptions, an output schema, and safety annotations. The description covers the core purpose, and remaining details like pagination and businessId behavior live in the schema. Slightly more explicit routing among similar page/account tools would make it fully complete.

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

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

Schema description coverage is 100%, so limit, cursor, and businessId are fully documented in the input schema. The description does not add parameter-specific meaning, making baseline 3 appropriate.

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

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

The description uses a specific verb ('List') and resource ('Facebook Pages') and enumerates the returned fields (id, name, category, tasks, picture, linked Instagram account references). This clearly distinguishes it from siblings like meta_get_business_assets and meta_get_instagram_accounts.

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

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

The description provides clear context: use this when you need accessible Facebook Pages with the listed fields. It does not explicitly name alternatives or exclusions, but the resource-specific wording gives enough guidance for an agent to select it correctly.

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, openWorldHint=true, idempotentHint=true, and destructiveHint=false, covering safety. The description adds useful behavior: it returns 'actionable warnings' for permission-limited edges, which is not in annotations. This enriches the agent's understanding of potential partial results.

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 sentence that is concise and front-loads the core purpose before mentioning the warning behavior. Every word contributes to the agent's understanding.

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 presence of an output schema reduces the need to describe return values, and the description covers the key behavioral nuance (warnings). However, it doesn't clarify edge cases like when both businessId and adAccountId are provided or how pagination interacts with warnings, but these are minor given the output schema exists.

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 (limit, cursor, businessId, adAccountId, includeDatasets). The description adds no extra parameter-level semantics, but it doesn't need to since the schema is complete. 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 specifies a clear verb ('List') and resource ('pixels and datasets') with context (ad account or Business Manager). However, it doesn't explicitly distinguish this from siblings like meta_get_business_assets or meta_get_entity_configuration, which could also list related assets.

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

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

The description mentions 'when accessible' and 'permission-limited edges', indicating conditional use, but it does not explicitly state when NOT to use it or point to alternatives. Given the many sibling tools, more specific routing would be helpful.

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 cover readOnly, idempotent, and non-destructive behavior, so the description only needs to add context. It adds that results are for conversion lift or A/B tests and enumerates the returned components (objectives, cells, lift results), but it does not mention anything about study status requirements, empty results, or pagination.

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. The core action and resource are front-loaded, and the second sentence adds the key return categories without unnecessary detail.

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

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

For a simple tool with one documented parameter, strong read-only annotations, and an output schema, the description is nearly complete. A small gap is the lack of explicit differentiation from the closely related interpret-experiment-results sibling, but the intended call context is still clear.

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

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

Schema description coverage is 100%, so the single required studyId parameter is already documented adequately. The description reinforces the parameter's meaning by referring to 'a conversion lift or A/B test study' but does not need to add more, so the baseline score of 3 is appropriate.

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

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

The description opens with a specific verb and resource: 'Get detailed results for a conversion lift or A/B test study,' which is clear and action-oriented. It further distinguishes itself from sibling tools by naming the resource type (study results) and the key return concepts (objectives, cells, lift results), so an agent can tell it apart from tools like meta_get_ad_studies or meta_interpret_experiment_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 description implies the tool should be used when an agent needs detailed results for a study, but it does not explicitly say when to prefer this over alternatives such as meta_get_ad_studies or meta_interpret_experiment_results. No exclusions, prerequisites, or when-not-to-use guidance are provided.

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

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

Annotations already establish read-only, idempotent, non-destructive behavior. The description adds meaningful behavioral context beyond that: 'direct video read alone never proves membership or readiness' and 'Bounded pagination; not_found is not success.' This gives agents important caveats about interpreting results and pagination, which annotations do not cover.

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

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

Four short sentences, each carrying distinct information: purpose, fallback strategy, an important caveat, and pagination/not_found semantics. The main verb and resource are front-loaded, and there is no 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 read-only tool with an output schema and strong annotations, the description covers the key behavioral subtleties: membership verification, bounded pagination, and not_found semantics. It could be more explicit about the exact meaning of 'video processing' and how pagination is exposed, but it is complete enough for correct invocation.

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

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

Input schema descriptions cover both adAccountId and videoId fully, so the baseline is 3. The description does not add substantive parameter-level detail; the reference to 'video title' is not backed by a title parameter in the schema, so it does not improve parameter understanding.

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

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

The description opens with a clear directive: 'Check video processing and membership in the selected account library.' This names the resource (uploaded video) and the specific checks (processing, membership), and 'account-scoped lookup' signals its scope. It doesn't name sibling tools like meta_list_ad_videos or meta_get_video_sources, and leaves 'processing' and 'membership' somewhat undefined, so it is clear but not maximally differentiated.

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

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

It gives practical usage hints: use the video title if the first page misses the ID, and remember bounded pagination and 'not_found is not success.' However, it does not explicitly say when to prefer this over sibling tools or when to avoid it, so usage 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?

The description adds meaningful behavioral context beyond the readOnlyHint/idempotentHint annotations: URLs are freshly minted, signed URLs expire quickly. This is exactly the kind of behavioral nuance annotations alone do not provide, and it matters for agent behavior at download time.

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

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

Two concise sentences with no wasted words. The core behavior is front-loaded — 'Resolve fresh download URLs and thumbnails' — and the temporal constraint follows immediately after the colon, making the key call-time behavior prominent.

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 resolver with full schema coverage, an output schema present, and safety annotations provided, the description covers the purpose, the trigger condition, and the key behavioral caveat. Nothing essential for a correct invocation is missing.

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

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

Schema description coverage is 100%, so the schema already documents adAccountId, videoIds, and pageId thoroughly. The description reinforces that videoIds are ad-video IDs to resolve and that URLs are fresh/short-lived, but it does not need to add much beyond the schema.

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

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

The description is specific and action-oriented: 'Resolve fresh download URLs (source) and thumbnails for specific ad videos.' It clearly identifies the resource, the verb, and the distinguishing trait — freshness/signed URLs — which separates it from nearby siblings like meta_get_uploaded_video and meta_list_ad_videos.

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

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

It explicitly says 'Call this at download time: the returned URLs are signed and expire quickly,' giving the agent a clear temporal condition for when to use this tool. It does not explicitly name alternative tools or exclusions, but the download-time framing is clear enough for 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, openWorldHint, idempotentHint, and destructiveHint=false, so the safety profile is covered. The description adds genuinely valuable context beyond annotations: the tool 'warns about missing read scopes' (a diagnostic behavior) and critically guarantees it does so 'without exposing the access token' — a security property no annotation covers. No contradiction with the readOnlyHint annotation; the description's 'read-only' aligns with it.

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 of 23 words, front-loaded with the core identity ('Agent-ready read-only health check') followed by a compact enumeration of the three behaviors. The closing safety clause ('without exposing the access token') earns its place as a high-value behavioral guarantee. Zero filler words; every clause adds information.

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

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

For a zero-parameter, read-only tool with a full annotation safety profile and an output schema that presumably documents return values, the description covers everything an agent needs to call it correctly: what it validates, what it lists, what it warns about, and the token-exposure guarantee. The only gap is the absence of sibling differentiation, which is more of a usage-guideline concern, and no mention of error behavior on an invalid token — minor given the output 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?

The tool has zero parameters and schema coverage is trivially 100%, so the baseline of 4 applies. There is nothing for the description to document or explain about inputs, and it correctly does not invent parameter guidance. The description's focus on behavior rather than inputs is appropriate for a no-arg health check.

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 composite action ('health check') with three concrete behaviors: validates token metadata, lists accessible ad accounts, warns about missing read scopes. This is far more specific than the title alone and effectively distinguishes the tool from single-purpose siblings like meta_debug_token or meta_list_ad_accounts. It stops short of a 5 only because it never explicitly names a sibling or contrast to preempt confusion.

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

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

Usage is implied rather than stated: 'Agent-ready' and the health-check framing suggest this is a preflight diagnostic an agent runs before performing operations, but no explicit when-to-use, when-not-to-use, or alternative routing is given. Given 40+ sibling tools, including the overlapping meta_debug_token, an explicit 'use this first, use meta_debug_token for deep token inspection' sentence would have moved this to a 4.

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

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

Annotations already declare readOnlyHint=true, idempotentHint=true, and destructiveHint=false, so no contradiction exists. The description adds that this is an interpretive/analytical read rather than a raw fetch, which is useful, but it does not disclose details like how missing studyId maps to adAccountId discovery or any rate-limit behavior.

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

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

The description is a single compact sentence with the core action front-loaded before the qualifying detail. The tail is a slightly dense list, but every phrase 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?

Given the annotations, an output schema, and fully described parameters, the description is nearly complete. It could improve by clarifying how this 'interpret' tool relates to meta_get_study_results or what form the interpretation takes, but an agent can select and call it safely with the current information.

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 limit, studyId, adAccountId, cellEntityType, and includeCellEntities. The description's mention of 'cells, objectives, and optional cell entities' loosely maps to cellEntityType/includeCellEntities, but it adds no information beyond what the input 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?

Description names a concrete verb-resource pair: 'Read and interpret A/B test or conversion lift study results,' and lists relevant facets (confidence guardrails, cells, objectives, optional cell entities). This is clearer than the bare title and distinguishes it from raw study-fetching siblings, though it doesn't explicitly contrast with meta_get_study_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 description implies the intended scenario: interpreting experiment study results rather than merely fetching them. It does not explicitly name alternatives (e.g., meta_get_study_results for raw results) or give when-not-to-use guidance, but the phrase 'A/B test or conversion lift study results' provides enough context for an agent to infer the primary use.

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

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

Annotations already declare the tool read-only, idempotent, and non-destructive, so the safety profile is covered. The description adds useful context about conditional enrichment with Product Catalog metadata, but it does not explain what happens if catalog access is unavailable, whether enrichment is best-effort, or how the join affects returned rows.

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 main action and contains no filler. Every word contributes to conveying the tool's purpose and the conditional enrichment 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?

The rich input schema, output schema, and annotations cover most operational detail, so the description does not need to repeat them. However, the tool is complex with 9 params, and the description leaves the conditional catalog-access behavior vague and omits guidance on selecting this tool over sibling insight tools, which is a meaningful 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 the schema already explains every parameter. The description does not add parameter-level detail beyond the concepts of 'product-breakdown insights' and 'Product Catalog metadata', which map to existing params but add no new semantic value. Baseline 3 applies.

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

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

The description clearly identifies the tool's operation: 'Query product-breakdown insights and enrich rows with Product Catalog metadata'. This distinguishes it from general insights tools by specifying the product-breakdown dimension and catalog join. However, it does not explicitly mention or differentiate from sibling tools like meta_get_insights or meta_get_catalog_products.

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 a use case: when product-level insights are needed and catalog metadata is accessible. The phrase 'when catalog access is available' gives some context, but there is no explicit comparison to alternatives, no when-not-to-use guidance, and no mention of when the simpler meta_get_insights would be preferred.

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 read-only, idempotent, open-world, and non-destructive behavior. The description adds the token-scoped 'all accessible ad accounts' context and the exact fields returned, but does not mention pagination or rate-limit behavior. This is adequate but not rich.

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

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

Two sentences with the core scope front-loaded ('List all Meta ad accounts') and the return fields summarized briefly. Every sentence adds information without redundancy.

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

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

For a zero-parameter, read-only listing tool with an output schema and annotations covering safety, the description fully covers what the tool does and what it returns. No additional context is needed for an agent to select and invoke it correctly.

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

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

The tool has zero parameters and the input schema is empty, so there is no parameter semantics to document. The description's mention of the current token and the returned fields is sufficient for a no-argument call.

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 ('List') with a clearly bounded resource ('all Meta ad accounts accessible with the current token') and enumerates the returned fields. This differentiates it from sibling tools that target specific accounts or other asset types.

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

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

The intended use is implied: call this when you need an overview of every ad account reachable with the current token. However, it does not explicitly state when to prefer it over alternatives like meta_get_account_details or meta_get_business_assets.

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 readOnly, openWorld, idempotent, and non-destructive. The description adds useful context: returns permanent display URL vs short-lived CDN URLs, and includes optional creative usage. It doesn't contradict annotations. The openWorldHint implies pagination, which is supported by the 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?

A single sentence with front-loaded resource and a clear list of returned fields, plus the optional includeUsage. 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?

Given the output schema exists, the return fields are covered. The description mentions pagination implicitly via the cursor and openWorldHint, but could explicitly state that not all images may be returned without pagination. However, the schema covers cursor and limit, so the description is sufficient.

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

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

Schema coverage is 100%, so parameters are fully described. The description reiterates the main return fields but doesn't add semantic detail beyond the schema. Baseline 3 is appropriate.

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

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

States a specific verb ('list') and resource ('ad account image library /adimages') and explicitly enumerates the fields returned. Clearly distinct from siblings like meta_list_ad_videos and meta_get_creative_assets, with the openWorldHint indicating partial returns.

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

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

The description clearly states the tool lists ad images with optional filtering and creative usage. It does not explicitly name alternatives or when not to use it, but the scope is evident. Could mention not to use for videos or other assets, but sibling names make the distinction clear.

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

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

Annotations already mark it read-only, open-world, idempotent, and non-destructive. The description adds valuable behavioral context beyond those annotations: publicly served thumbnails, short-lived source URLs that are returned only on request, and the specific API endpoint. No contradictions with annotations.

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

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

Two sentences, front-loaded with endpoint, scope, and returned fields, followed by a caveat about source URL expiry. Every clause carries information and there is no fluff.

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

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

With an output schema present and annotations covering read-only/idempotent behavior, the description does not need to explain return values. It covers endpoint, fields, and the one behavioral caveat (URL expiry) that affects invocation, making it sufficient for correct use.

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

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

Schema description coverage is 100%, so the baseline is 3. The description adds meaning beyond the schema by explaining the 'includeSource' trade-off (short-lived URLs) and the thumbnail size behavior, which is not present in the parameter schema.

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

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

The description uses a specific verb ('List') and resource ('ad account video library (/advideos)') and enumerates the returned fields: title, duration, processing status, and publicly served thumbnails. This clearly distinguishes it from sibling get/list tools without needing to 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 explicit alternatives or when/when-not conditions are provided; usage is implied by 'List the ad account video library.' The only guidance is that source file URLs are returned only on request because they expire quickly, which frames parameter choice rather than tool selection.

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

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

Annotations already declare readOnlyHint=true, idempotentHint=true, and destructiveHint=false, and the description's 'read-only' is consistent with them. The description adds meaningful context beyond annotations by disclosing the 'allowlisted' edge restriction and the fallback role for newly added fields. It does not discuss auth or rate limits, but the output schema and read-only annotations cover the main safety profile.

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

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

Two sentences carry the full message: first the core behavior and mechanism, then the use-case guidance. There is no filler, repetition of schema details, or unnecessary prose.

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 complex 11-parameter schema, 100% schema coverage, full annotations, and an output schema, the description is complete enough. It explains the operation, the allowlist constraint, and when to fall back to this tool rather than a specialized sibling, leaving no material gap an agent needs to call it correctly.

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

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

Schema description coverage is 100%, with every parameter having a description, enum, bounds, or pattern, so the baseline is 3. The description's phrase 'caller-selected flat fields, filters, and cursor pagination' loosely maps to the fields, filtering, before, after, and limit parameters, but adds no meaning 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 opens with a precise verb and resource: 'List an allowlisted read-only Meta Graph edge', and adds caller-selected fields, filters, and cursor pagination. It further distinguishes itself from specialized siblings by describing the tool as broad metadata/entity discovery for newly added fields, making selection unambiguous.

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

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

The description explicitly states when to use this tool: broad metadata/entity discovery when a specialized tool does not expose a newly added field, which implies specialized tools are preferred when they do cover the need. It does not name specific sibling tools or give explicit 'do not use for X' exclusions, so it is clear but not fully exhaustive.

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, idempotentHint, and destructiveHint=false, so the safety profile is covered. The description adds account-scoped search-by-name behavior, but it does not add extra behavioral details such as substring/case behavior, inclusion of deleted entities, or pagination semantics beyond what the schema already says.

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 the key verb and resource front-loaded. The second sentence adds a practical use case without redundant elaboration.

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

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

With a fully documented 6-parameter schema, an output schema, and annotations for read-only/idempotent/non-destructive behavior, the description is sufficient for correct invocation. It does not need to describe return values, and no critical operational detail is missing.

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

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

Schema description coverage is 100%, so the baseline is 3 even without parameter details in the description. The description does not add meaning beyond the schema, merely restating the name filter and ad account scope.

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 action (search), resource (campaigns/ad sets/ads), and scope (by name within an ad account), so an agent can grasp what the tool does. It does not explicitly call out how this differs from sibling get/search tools such as meta_get_campaigns or meta_search_targeting_options, so it stops short of full sibling 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?

"Useful for finding specific entities" provides an implied use case, but there is no explicit when-to-use/when-not-to-use guidance and no reference to alternative tools among the many sibling list/search tools. An agent must infer when this should be preferred over meta_get_campaigns/meta_get_adsets/meta_get_ads.

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, openWorldHint, idempotentHint, and destructiveHint=false, so the safety profile is fully covered. The description reinforces 'read-only' and adds the targeting-metadata context, but it does not disclose additional behavior such as pagination behavior or rate limits; this is a minor gap given the strong 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?

It is one front-loaded sentence with no filler: the action, resource, and scope all appear immediately, and the list of targeting categories is compact. Every part of the 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?

Given the full input schema descriptions, a rich output schema, and annotations covering safety and idempotency, this one-sentence description is sufficient for an agent to select and invoke the tool correctly. No critical behavioral or parameter context is missing.

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

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

With 100% schema description coverage, the schema already documents all five parameters, so a baseline of 3 applies. The description adds some semantic help by mapping the `type` enum values to business categories, but it does not add meaning for limit, query, countryCode, or locationTypes beyond the schema.

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

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

The description opens with the verb 'Search' and the concrete resource 'Meta's read-only targeting metadata,' then names the categories it covers: interests, validated interests, geographies, locales, countries, cities, regions, markets, and postal codes. This makes the tool's scope unambiguous and distinguishes it from broad sibling tools like meta_search_entities.

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 intended use is implied by the targeted scope, but the description never states when to prefer this tool over alternatives such as meta_search_entities or meta_validate_query, nor does it give when-not-to-use conditions. An agent can infer the use case, but not with 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, idempotentHint, and destructiveHint, covering the safety profile. The description adds value beyond annotations by stating the tool returns errors and warnings and is meant to run before execution, which clarifies its behavioral role without contradicting the hints.

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 zero filler. The core purpose is front-loaded ('Validate... BEFORE executing'), and the return type is stated immediately after. Every word earns its place.

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

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

For a simple validation tool with only 3 parameters, full schema coverage, a safety profile in annotations, and an output schema present, the description covers purpose, timing, and usage completely. Nothing an agent needs to call it correctly is missing.

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

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

Schema description coverage is 100%, so the parameters are already well documented. The description mentions 'metric/breakdown combination', which loosely maps to metrics and breakdowns, but adds no additional semantic detail beyond what the schema provides. 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 uses a specific verb ('Validate') and resource ('metric/breakdown combination'), which clearly states what the tool does. It also adds the temporal context 'BEFORE executing' and names its output ('errors and warnings'), making it unambiguous and distinct from the many get_* 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 final sentence, 'Use this to check if your query will work,' gives explicit when-to-use guidance. It doesn't name specific alternatives or exclusions, but the pre-execution validation role is clear enough for an agent to select it over execution tools like meta_get_insights.

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