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

Annotations already declare readOnly, idempotent, non-destructive and open-world, so the safety profile is covered. The description adds real value beyond them: a disclosed failure mode where self-inspection is refused and the result degrades to user/permission checks, with token and app metadata explicitly reported as unknown. The phrasing of the refusal condition is somewhat oblique, keeping it short of a 5.

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, both load-bearing, with the primary capability front-loaded and the caveat second. The fallback clause is dense and slightly tangled ('with itself'), costing a point on readability rather than length.

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, return values need not be described, and annotations cover safety. The description supplies the one thing structured fields cannot: what happens when the token cannot inspect itself and which fields become unknown. That is sufficient for a zero-parameter read tool.

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

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

The tool takes no parameters and the schema is empty, so there is nothing for the description to disambiguate. Baseline for a zero-parameter tool is 4.

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

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

States a specific verb ('Inspect') and resource ('token') and enumerates exactly what is returned: identity, validity, expiry and scopes. None of the ~40 sibling tools do token introspection, so the agent can route here without comparison.

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 second sentence gives a clear triggering condition ('When Meta refuses to inspect this token with itself') and names the fallback behavior (independently check connecting user and granted permissions). It does not state when not to use it, but the diagnostic use case 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 declare readOnlyHint, idempotentHint, destructiveHint=false and openWorldHint=true, so the safety profile is covered. The description adds useful context by enumerating the returned field categories, but says nothing about behavior on invalid/suspended accounts, rate limits, or the implications of openWorldHint (a live external call).

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

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

One front-loaded sentence with the verb and resource first and the payload described after the colon. No filler, no repetition of the title.

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?

An output schema exists and annotations cover safety and idempotency, so return-value and safety detail are not the description's burden. For a one-parameter read, the description is nearly complete; only the relationship to sibling account-level tools is left implicit.

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

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

Single parameter with 100% schema description coverage including an 'act_123456789' format example, so the schema carries the load. The description adds nothing about the ID format (e.g., that the act_ prefix is expected) or validation, so baseline 3 applies.

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

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

States a specific verb ('Get detailed information') and a specific resource ('a specific Meta ad account'), then enumerates the fields returned. It is clearly distinct from meta_list_ad_accounts by being single-account scoped, but it never names that sibling to make the contrast explicit.

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

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

The phrase 'for a specific' implies you must already have an ad account ID, which is reasonable implicit guidance. However, there is no statement of when to prefer this over meta_list_ad_accounts or meta_get_business_assets, and no prerequisites or error conditions are given.

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

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

Annotations already declare readOnlyHint=true, idempotentHint=true, destructiveHint=false, and openWorldHint=true, so the safety profile is fully covered. The description adds the endpoint path and lists the returned fields, which is useful context beyond annotations, though the field list is partially redundant with the output schema.

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

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

The description is a single, front-loaded sentence that states the action, endpoint, and key return fields with zero wasted words. It is appropriately sized for a simple read 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 that the tool has rich annotations, full schema description coverage, and an output schema, the description is complete enough for an agent to call it correctly. It only lacks minor details such as pagination behavior, which is already covered by the schema's limit/cursor descriptions.

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 every parameter (adAccountId, limit, since, until, cursor) is already documented in the schema. The description adds no additional meaning about parameter formats, defaults, or interactions beyond what the schema provides, 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 names a specific verb (Read), a specific resource (ad account activity logs), and the exact endpoint path (/{ad_account_id}/activities), along with the fields returned. This clearly distinguishes it from all sibling tools, none of which deal with activity logs.

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 by stating that it reads activity logs, but it does not explicitly say when to use this tool versus alternatives, nor does it mention any exclusions or prerequisites. The context is clear enough that an agent can infer this is for audit/activity purposes.

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, non-destructive behavior, and the description reinforces rather than contradicts them. It earns credit for disclosing something not in the structured fields: that the response payload may include an iframe body, and that no creative is created or edited. It does not cover rate limits or placement-compatibility failure modes.

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

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

Two short sentences, front-loaded with the core action and payload, then the safety clarification. Nothing is redundant or padded.

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?

A low-complexity, two-parameter read tool with rich annotations, full schema coverage, and an output schema that already defines return values. The description covers the one thing structured fields cannot: that the preview markup may embed an iframe and performs no writes.

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 documented in the input schema. The description only gestures at the adFormat concept via 'requested placement format' and adds no new detail about format compatibility or ID sourcing beyond what the schema states.

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

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

Uses a specific verb ('Get') on a specific resource ('read-only preview markup for an existing Meta ad in a requested placement format'), which clearly separates it from retrieval tools like meta_get_ads or meta_get_creatives. It does not explicitly name or contrast with any sibling, 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 intent (fetch a rendered preview for an existing ad) is implied by 'existing Meta ad' and 'requested placement format', but there is no explicit when-to-use statement, no prerequisite such as needing an ad ID from a prior call, and no named alternative to use instead.

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, so the safety profile is covered. The description adds the returned field set (ad ID, name, status, creative reference), which is helpful, but says nothing about pagination behavior, limits, or the openWorldHint=true implication that results reflect live external state.

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, zero filler, with purpose and scope front-loaded before the return-value clause. Nothing could be removed without losing 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?

An output schema exists, so the return clause is redundant but harmless; parameters are fully covered by the schema. For a filtered-list tool this is essentially complete, with only pagination/limit behavior left implicit (though the limit schema description does cover 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 coverage is 100%, so each parameter (including the adSetId/adsetId alias rule and the statusFilter enum semantics) is already fully documented in the schema. The description only echoes the ad-set filter, adding no syntax or edge-case detail beyond what the schema provides, so baseline 3 applies.

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

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

States a specific verb and resource ("List ads for a Meta ad account") plus the primary scoping option (ad set filter). An agent can distinguish it from siblings like meta_get_adsets or meta_get_creatives, though the description never explicitly names those alternatives.

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

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

There is no explicit guidance on when to choose this tool over meta_get_adsets, meta_get_creatives, or meta_get_insights, nor any prerequisites. The only hint is the parenthetical 'optionally filtered by ad set', which is usage-adjacent but not conditional guidance.

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

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

Annotations already declare readOnlyHint=true and idempotentHint=true, so 'no mutation' is largely redundant, but 'returns native settings' adds genuinely new context (values are raw platform values, not normalized) and the creativeRequirements/applink_treatment note discloses a non-obvious field for cross-channel ad sets. That goes beyond what the annotations convey.

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

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

Three short sentences, front-loaded with the action and use case, then the cross-channel caveat. The closing 'Returns native settings; no mutation' partially repeats the readOnly annotation, which is the only wasted clause.

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?

An output schema exists and annotations cover safety, so the description needn't explain return format. It supplies the pre-edit use case and the cross-channel creativeRequirements nuance, leaving only minor gaps such as what 'native settings' excludes or how errors surface.

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

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

Schema description coverage is 100% with both adSetId and adAccountId fully documented, including the warning not to substitute campaign or business IDs. The description adds no parameter-level detail of its own, 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?

States a specific verb (Read) and resource (an existing ad set) and broadens scope to parent campaign budget/objective and account currency, which tells the agent exactly what payload to expect. It does not name a sibling such as meta_get_adsets or meta_get_entity_configuration to sharpen the distinction, so it falls 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?

The phrase 'before preparing an edit or adding ads' gives a concrete trigger condition, which is real usage guidance rather than a restatement of the name. It stops at positive guidance and never says when to prefer a sibling or when this read is unnecessary.

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 known. The description adds useful context about returned data categories (targeting, budget, optimization, schedule), but does not mention pagination behavior or any rate limits beyond what the schema 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?

Two short sentences with no filler, front-loading the core purpose and following with return categories. It is appropriately sized for the tool's complexity.

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

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

The tool has an output schema, rich annotations, and fully documented parameters, so it does not need to explain return values in detail. The description covers the main operation and filter, though it could mention pagination constraints explicitly for completeness.

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

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

Schema description coverage is 100%, so all parameters are already well documented. The description only adds the high-level fact that results can be filtered by campaign, which maps directly to the already-documented campaignId parameter.

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

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

The description states a specific verb and resource ('List ad sets'), scopes it to a Meta ad account, and notes the optional campaign filter. It is clearly distinct from siblings like meta_get_campaigns or meta_get_ads, though it does not explicitly name alternatives.

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

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

The phrase 'optionally filtered by campaign' implies a common usage pattern, but there is no guidance on when to prefer this tool over siblings such as meta_get_campaign_structure or meta_get_ads, nor any exclusions or prerequisites.

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

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

Annotations already declare readOnlyHint=true, idempotentHint=true and destructiveHint=false, so the safety profile is covered structurally. The description adds which study categories are returned (conversion lift, A/B) and that cells are included, which is modest added context but nothing on pagination, permissions, or result limits for an openWorld endpoint.

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, and the resource definition is front-loaded before the field inventory. Every sentence carries 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 one fully documented parameter and an output schema present, the definition need not explain return values, and it correctly limits itself to stating scope and included fields. It could be slightly more complete by noting pagination or the relationship to meta_get_study_results for drilling into results.

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?

There is a single parameter with 100% schema description coverage ('Ad account ID (e.g., act_123456789)'), so the schema fully documents it. The description adds no format or constraint detail beyond that, 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 names a specific verb ('List') and resource ('conversion lift studies and A/B tests (Ad Studies)') scoped to an ad account, which is more precise than the tool name alone. It does not explicitly differentiate itself from the closely related sibling meta_get_study_results, so it falls 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?

Usage is only implied by the phrase 'for an ad account'; there is no statement of when to use this versus meta_get_study_results or meta_interpret_experiment_results, which occupy adjacent territory. No prerequisites or exclusions are given.

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

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

Annotations already declare readOnly, idempotent, non-destructive, and open-world behavior, so the safety profile is covered. The description adds only two behavioral facts beyond that: results are paginated and fields are permission-gated. It says nothing about result volume, permission failure behavior, or whether an ad account scope is required.

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, which is efficient. It is arguably too terse given the sibling ambiguity, but 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?

The tool is read-only, has an output schema covering return values, and full schema coverage on all parameters, so much of the burden is already carried. What is missing is the one thing the description alone can supply: how this differs from meta_get_audiences and what the 'rich fields' actually add.

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 five parameters (type, limit, cursor, adAccountId, audienceIds) are already documented in the schema, making 3 the baseline. The description adds no parameter-level meaning beyond what the schema states, but it does not need to.

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) and resource (custom, saved, and lookalike audiences) with modifiers for pagination and field richness, so the operation is unambiguous. However, it never distinguishes itself from the sibling tool meta_get_audiences, leaving an agent to guess which of the two audience readers to call.

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?

'where permissions allow' is a caveat rather than usage guidance; it does not tell the agent when to prefer this over meta_get_audiences or when to fall back. There are no exclusions, no prerequisites, and no scenario descriptions.

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 safety and mutability are fully covered. The description adds only the enumeration of audience subtypes; it says nothing about pagination behavior or result scoping beyond what the schema's limit parameter already conveys.

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 waste, and the resource scope appears first. It is arguably too terse given the tool's role, but nothing is padded.

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 rich annotation set, full schema coverage, and an output schema handling return values, the description does not need to explain much more. The only real gap is the lack of routing guidance against meta_get_audience_details.

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

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

Schema description coverage is 100%, with the type enum and limit bounds/default fully documented in the schema. The description mirrors the type enum values but adds no syntax, format, or constraint detail beyond that, so baseline 3 applies.

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

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

States a specific verb (List) and resource (audiences) and enumerates the subtypes covered (custom, saved, lookalike), which distinguishes it from the sibling meta_get_audience_details. It does not explicitly name that sibling, so it falls 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?

Usage is implied by 'List ... for a Meta ad account', but there is no explicit when-to-use guidance and no mention of when to prefer meta_get_audience_details over this bulk listing tool. The agent must infer the boundary.

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

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

Annotations already establish readOnlyHint, idempotentHint, and destructiveHint=false, lowering the burden. The description adds that output spans targeting-derived signals plus optional block-list edges, but says nothing about permission requirements for Business Manager block lists (openWorldHint=true implies external dependency), rate limits, or pagination behavior beyond what the schema states.

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 listing the signal categories and their source, with no filler. It is dense but every clause carries scope information; only mild ambiguity from packing four signal types into one list keeps it off a 5.

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

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

With an output schema present and fully documented parameters, the description only needs to frame what class of data comes back, which it does ('brand safety, suitability, placement, and context-control signals'). What remains thin is the block-list/Business Manager dependency, which is only gestured at via the optional businessId parameter.

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 every parameter including limit, cursor, adsetIds, businessId, and the three include* flags is already documented in structured data. The description only loosely maps its wording onto adAccountId/adsetIds/businessId and adds no format or interaction details beyond the schema, so baseline 3 applies.

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

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

States a specific verb (read) and a specific resource class (brand safety, suitability, placement, context-control signals), plus the source (ad account/ad set targeting and block-list edges). It is clearly distinguishable from the sibling list, which contains no other brand-safety tool, though it does not explicitly name an alternative.

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 'read ... from ad account/ad set targeting' implies an inspection/audit use case, and the optional block-list edge mention hints at a secondary mode. But there is no explicit when-to-use, when-not-to-use, or routing to a sibling such as meta_get_adset_configuration or meta_search_targeting_options.

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

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

Annotations already cover readOnly/idempotent/non-destructive/openWorld, and the description adds a genuinely non-structured fact: that each asset class is returned only 'when permissions allow', warning the agent not to treat an empty section as proof of absence. It does not explain what happens on permission failure (error vs. omission) or describe paging behavior, but the safety profile is already carried by 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 that packs the verb, the resource, the enumerated asset types, the read-only guarantee and the permission caveat with zero filler. Nothing is restated or padded.

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 full input schema and an output schema present, the description need not explain parameters or return shape; it covers scope and the permission caveat, which is what's missing from structured fields. The only shortfall is that it does not hint that passing businessId/adAccountId switches the tool into a narrower owner-discovery mode.

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, cursors, maxPages, businessId and adAccountId are all fully documented in the schema, which sets the baseline at 3. The description mentions no parameter at all — not even the businessId/adAccountId scoping that materially changes what is discovered — so it adds nothing beyond the schema.

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

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

The description uses a specific verb ('Discover') plus a named resource class ('Meta Business assets') and enumerates the concrete asset types returned: businesses, pages, Instagram accounts, pixels, datasets. This lets an agent understand it is a broad cross-asset discovery tool, though it never names the narrower siblings (meta_get_pages, meta_get_pixels, meta_get_instagram_accounts) it overlaps with.

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 clause 'when permissions allow' signals that results are conditional, which implies usage context, but there is no explicit statement of when to prefer this tool over the per-asset siblings like meta_get_pages or meta_get_pixels. An agent must infer that this is the umbrella discovery tool versus the targeted listing 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 readOnly=true, idempotent=true, destructive=false, openWorld=true, so the safety profile is fully covered structurally. The description adds no behavioral context beyond that — nothing about rate limits, permission requirements, or the pagination ceiling — and its field list is redundant given an output schema 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?

Two sentences, correctly front-loaded with purpose before output detail, and no filler. Nothing to cut.

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 rich annotations, a fully documented 4-parameter schema, and an output schema, the definition is sufficient to call the tool correctly. The only real gap is routing guidance against the many similarly named campaign/asset siblings.

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% and the statusFilter in particular carries unusually good semantics (native effective_status vs configured status, PAUSED implications, the advice to omit for post-creation verification). The description contributes nothing 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?

States a specific verb and resource ("List campaigns for a Meta ad account") plus returned fields, so the agent knows exactly what it gets. It does not, however, differentiate from plausible siblings such as meta_get_campaign_structure or meta_get_ads, leaving the agent to infer the boundary.

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 scope (a single ad account, campaigns only) implies when to use it, but there is no explicit when-to-use, when-not, or named alternative. The nearest ambiguous siblings (structure, adsets, ads) are never addressed.

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, non-destructive, and open-world, so the safety profile is covered. The description adds the hierarchy depth (three levels) as real context, but says nothing about pagination, result size, or whether lower levels are always nested.

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

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

Two short sentences, front-loaded with the hierarchy shape. The second sentence is mildly redundant filler but still signals intent, so no trimming penalty beyond that.

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 an output schema exists and annotations cover safety, the description is nearly complete for this 2-param read tool. The only omission is any hint about depth-limit or ordering behavior of the returned tree.

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% and both parameters are documented inline, including the campaignId scoping note. The description adds no syntax, format, or behavior information beyond what the schema already provides, 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?

States a specific verb and resource ('Get hierarchical campaign structure') and specifies the exact shape returned: campaigns -> ad sets -> ads. This differentiates it implicitly from flat list siblings like meta_get_campaigns and meta_get_adsets, though those siblings are never named.

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?

Only a vague steer is given ('Useful for understanding account organization'); no explicit when-to-use, when-not-to-use, or named alternative such as meta_get_campaigns/meta_get_adsets for flat retrieval. An agent must infer the choice.

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 this as a read-only, idempotent, non-destructive operation. The description adds useful behavioral context by noting that per-item errors can exist even when the batch was accepted, which is more than the annotations provide.

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 language. The key action is front-loaded and the important caveat follows immediately.

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

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

For a read-only status tool with three fully documented parameters, annotations, and an output schema, the description gives enough context to use it correctly. The per-item error caveat is the main behavioral nuance an agent needs.

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

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

Schema description coverage is 100%, so the input schema already fully documents all three parameters. The description reinforces that the handle is a catalog batch handle, but adds no additional parameter syntax or constraints 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 states a specific verb and resource: reading completion and per-item errors for a catalog batch handle. It is clearly distinct from catalog product listing, but it does not explicitly differentiate itself from any sibling tool by name.

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

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

The tool's usage is clearly implied: inspect a batch handle after submission, especially because batch acceptance does not guarantee every product succeeded. It does not name alternatives or 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=true, destructiveHint=false, idempotentHint=true, and openWorldHint=true. The description reinforces the non-mutating behavior by saying it returns metadata 'without creating or updating catalog assets' and mentions a catalog-access prerequisite, but adds little beyond the annotation 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?

The description is two tight sentences, front-loaded with the core read operation and scoped by the non-mutating guarantee. There is 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?

An output schema exists and the input schema is fully described, so the description need not explain return values or parameters in depth. It gives the essential read-only catalog context, but could better clarify how this tool relates to adjacent catalog and product-insight 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 all eight parameters are already well documented in the input schema. The description does not add parameter-level semantics such as how catalogId, businessId, and productIds interact, so it meets the baseline for high schema coverage rather than exceeding it.

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

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

The description uses a specific verb and resource: 'Read Product Catalogs and Product Items', and adds that it returns 'join-ready product metadata'. It clearly states what the tool does, though it does not explicitly distinguish itself from siblings such as meta_join_product_insights or 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?

It gives a prerequisite context ('when catalog access is available') but does not explain when to choose this tool over alternatives like meta_get_business_assets for catalog discovery or meta_join_product_insights for joining product data. Usage is implied rather than explicitly guided.

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, openWorldHint=true, and destructiveHint=false, so safety behavior is largely covered. The description adds useful context about returned media components, separate catalog-only classification, and availability of raw creative metadata for diagnostics, though it does not discuss permissions or rate limits.

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

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

The description is three sentences and front-loads the core return content. Each sentence provides useful context, though the hosted gallery mention is somewhat tangential and could be trimmed if space were at a premium.

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 complete schema descriptions, rich annotations, and an output schema, the description provides enough behavioral and output context for an agent to call the tool correctly. It does not need to explain return values in detail because 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?

The input schema has 100% description coverage and clearly documents all five parameters, including adIds, creativeIds, adAccountId, limit, and cursor. The description does not add meaning beyond the schema for these parameters, 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 verb and resource: it returns ad-linked creative media and enumerates the included asset types such as collection covers, carousel components, image hashes, and video URLs. It separates catalog-only ads and mentions the hosted gallery alternative, though it does not explicitly distinguish itself from the sibling meta_get_creatives 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?

It gives clear context for using the hosted GetMCPAds service for an interactive visual gallery and implies this tool is for raw diagnostic metadata, but it does not state when to choose this over sibling tools such as meta_get_creatives, meta_list_ad_images, or meta_list_ad_videos. Usage is therefore implied rather than fully guided.

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, openWorldHint, and destructiveHint=false, so the safety profile is fully covered by structured data. The description adds the shape of returned content (creative asset types), but says nothing about pagination behavior, rate limits, or what happens when adIds is omitted (the required adAccountId fallback).

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

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

Two short sentences, front-loaded with the verb and returned content types, with zero filler. It is efficient, though the trailing sentence ("Returns creative details for specified ads") partially restates the first.

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?

An output schema exists, so return values needn't be spelled out, and annotations carry the safety semantics. What remains missing for a crowded 40-sibling namespace is sibling disambiguation and a note on the adIds-optional listing behavior, which the description does not supply.

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 adIds, limit, and adAccountId are all documented in the schema itself, establishing a baseline of 3. The description adds no meaning beyond the schema — notably it never explains the behavior when adIds is empty, which is the one semantic gap the schema leaves open.

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?

Uses a specific verb+resource ("Get ad creative content") and enumerates the fields returned (text, images, videos, links, CTA), which tells an agent exactly what data this yields. It does not, however, differentiate itself from near-siblings like meta_get_creative_assets, meta_list_ad_images, or meta_list_ad_videos, which overlap in scope.

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

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

The description states what the tool returns but never says when to reach for it versus meta_get_creative_assets or the image/video listing tools. There are no exclusions, prerequisites, or alternative routing hints, leaving the agent to guess among several plausible 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, idempotentHint, destructiveHint=false, and openWorldHint, so the description repeating 'read-only' adds nothing. It does add modest value by flagging that status/issue fields are only present 'where available' and that the insights returned are 'simple', but it says nothing about pagination behavior or partial-failure handling for a multi-level aggregation.

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 dense sentence with the aggregation intent front-loaded and no wasted words. It is efficient, though the compressed phrasing ('issues_info where available') assumes familiarity with Meta field names.

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?

An output schema exists and annotations cover the safety profile, so return values need not be explained. However, for a 7-parameter, multi-level aggregation tool sitting among many insight/hierarchy siblings, the description leaves level semantics and pagination contract unaddressed, so it is adequate but with clear gaps.

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

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

Schema description coverage is 100%, so level, limit, cursor, timeRange, datePreset, adAccountId, and effectiveStatusFilter are all documented in the schema itself. The description maps loosely onto the status/issue filters and the lightweight insights, but adds no format, default, or interaction guidance beyond that, making baseline 3 correct.

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

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

States a specific verb (aggregate) and resource (delivery diagnostics) with explicit scope across campaigns, ad sets, and ads, and names the fields it draws on (status/effective_status/issues_info). It does not explicitly distinguish itself from close siblings like meta_get_insights or meta_get_ad_activity, 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 word 'diagnostics' implies troubleshooting rather than performance measurement, which implicitly separates it from insights tools, but there is no explicit when-to-use, when-not-to-use, or named alternative. With 40 siblings, an agent must infer the routing decision.

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

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

Annotations already declare readOnlyHint=true and idempotentHint=true, but the description adds useful behavioral context: it never creates, changes, or retries the entity, and it warns that missing or normalized fields must be inspected before claiming an exact match. This goes beyond restating the annotations.

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

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

The description is three short sentences, front-loads the core purpose, and includes only directly relevant caveats. Every sentence contributes to understanding or safe use.

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?

An output schema exists and annotations are rich, so the description need not explain return values or safety guarantees in depth. It adds a reconciliation caveat and normalization warning, though it still leaves some ambiguity about which entity types this covers relative to sibling tools.

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

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

Schema description coverage is 100%, so the schema already documents all three required parameters, including the fields enum and ID formats. The description does not add parameter-specific meaning 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 states a specific verb and resource: reading a specific entity in its ad account for reconciliation. It is clear enough to understand the operation, but it does not distinguish this generic entity read from specific sibling tools such as meta_get_adset_configuration or 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 phrase "for reconciliation" implies the intended use case, and the note about missing or normalized fields provides a workflow caveat. However, it does not explicitly say when to use this tool versus sibling configuration readers or when not to use it.

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

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

Beyond the read-only annotations, the description discloses important behavior: the query planner splits incompatible metric/breakdown combinations into multiple API requests and merges results. It also warns about conversion semantics and overlapping purchase types, though it does not cover rate limits or error behavior.

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

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

The description is front-loaded with purpose and resource pointers, and every sentence provides useful context. It is slightly dense and repeats the query-planning idea, but it avoids unnecessary 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 an 18-parameter insights tool with annotations and an output schema, the description covers the most important behavioral and query-semantic context. It is not fully complete because it omits explicit sibling routing and some operational caveats.

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

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

Schema coverage is 100%, so the schema documents parameters well. The description adds meaningful semantics beyond the schema by explaining metric/breakdown resources, conversion analysis behavior, action_type labeling, and the pitfalls of the native conversions field.

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

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

The description states a specific verb and resource: query Meta Ads performance insights, including metrics/breakdown support. It is clear about what the tool does, but it does not explicitly distinguish itself from the sibling meta_get_insights_raw.

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 implied usage guidance by pointing to meta://metrics and meta://breakdowns and by explaining how to handle purchases/leads/conversion analysis. However, it does not state when to use this tool versus alternatives such as meta_get_insights_raw or meta_validate_query.

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

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

Annotations already declare readOnly, idempotent, openWorld, non-destructive, so the safety profile is covered. The description adds meaningful context beyond that: fields must be validated native names and calculated aliases are rejected, and this tool exists as a forward-compatibility escape hatch. It does not mention rate limits or Meta's async report behavior, keeping it from a 5.

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 tight sentences, with the core action and scope front-loaded and the sibling differentiation immediately after. No filler or restatement of the title.

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 full schema coverage, the description only needs to convey intent and when to reach for it, which it does. It could add a note about compatibility constraints when combining breakdowns or the timeRange vs datePreset choice, but those are mitigated by schema descriptions.

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 14 parameters including enums, patterns, and defaults. The description only echoes the capability list (breakdowns, attribution windows, filters, sort, summary, pagination) without adding syntax or constraint detail beyond the schema, so baseline 3 applies.

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

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

The description names a specific verb (Query) and resource (the Meta Insights edge) and enumerates the capabilities it exposes, then explicitly contrasts itself with meta_get_insights as the raw/early-field path. An agent can distinguish it from the curated sibling without opening either schema.

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 states the selecting condition clearly: use this when Meta adds fields before the curated metric catalog is updated. The alternative (meta_get_insights) is named, though the inverse guidance ('prefer meta_get_insights for standard curated metrics') is only implied rather than stated.

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

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

Annotations already declare readOnly, idempotent, non-destructive, and openWorld, so safety is covered. The description adds a permission-gating caveat, which is genuinely useful, but says nothing about behavior when no scoping ID is supplied or about result completeness.

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; the resource and its scoping sources come first and the caveat trails.

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 full output schema and fully described parameters, the definition covers most of what an agent needs. The remaining gap is what happens when no filter is passed — whether it fans out across all accessible assets — which affects call strategy.

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

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

Schema coverage is 100%, so each parameter is already documented, including bounds and pagination semantics. The description corroborates that pageId, businessId, and adAccountId are alternative scoping paths, but adds no syntax or format detail 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?

Uses a specific verb (List) plus a concrete resource (Instagram accounts) and names the three linking sources. It is clearly distinguishable from siblings like meta_get_pages or meta_list_ad_accounts, though it does not explicitly state the distinction.

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

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

The three optional ID parameters imply which lookup path to take, and 'when permissions allow' hints at a prerequisite, but there is no explicit when-to-use/when-not-to-use guidance or named alternative tool.

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

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

With readOnlyHint, idempotentHint, and destructiveHint already declared, the safety profile is covered by annotations. The description's 'GET-only' largely restates readOnlyHint and 'nested field expansion is intentionally disabled' is already in the schema, so it adds limited behavioral context. No mention of token/permission requirements per node type or Graph rate-limit implications for an openWorld endpoint.

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 resource. The list of node types is long but earns its place by telling the agent the reach of the tool across campaign, ad set, creative, audience, catalog, Page, Instagram, and pixel nodes.

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?

An output schema exists, so return-value explanation is unnecessary, and annotations carry the safety profile. What remains is scope: which node types are reachable and the flat-only constraint, both stated. Auth/permission coverage for arbitrary node types is the one gap worth noting.

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%: nodeId, fields, and includeMetadata all carry their own descriptions and validation patterns. The description adds nothing beyond that, so the baseline 3 for schema-covered params 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?

States a specific verb and resource: 'Read arbitrary flat fields from one Meta Graph node.' The 'escape hatch ... without waiting for a fixed MCP schema update' framing implicitly separates it from the fixed-schema siblings (meta_get_campaigns, meta_get_ads, etc.), but no sibling is named explicitly, so an agent must infer the boundary rather than read it.

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?

'Escape hatch' plus 'newly released ... fields without waiting for a fixed MCP schema update' gives a clear condition for reaching for this tool: when the field you want isn't in a fixed-schema tool. It stops short of an explicit preference order (e.g. 'prefer meta_get_campaigns for standard campaign fields') and names no when-not cases.

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

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

Annotations already declare readOnlyHint, idempotentHint, openWorldHint, and non-destructive behavior, so the safety profile is covered. The description adds scope context about content versus ads insights, but does not add permission details, rate-limit behavior, or pagination context beyond what the schema provides.

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 no wasted wording. The primary purpose is front-loaded, and the second sentence adds a targeted disambiguation warning.

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 schema coverage and an output schema, the description is nearly complete for selection and invocation. Its main remaining gap is sibling routing: it distinguishes Ads Insights but not the adjacent organic-content or page-post 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 all 11 parameters are already documented in the schema. The description only adds high-level meaning around URLs, native periods, and optional insights, without explaining parameter relationships or selection logic.

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 resources: reading Facebook Page posts and Instagram media enriched with URLs, native periods, and optional insights. It clearly distinguishes this from Ads Insights, though it does not name or disambiguate against the close sibling meta_get_page_posts.

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

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

It gives a useful exclusion: these are content insights, not Ads Insights, and warns not to infer an organic-only breakdown. However, it does not say when to use this tool instead of siblings such as 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/non-destructive, so the bar is lower, and the description still adds real context: the token is resolved from the connected user and the returned fields (PageID_PostID, message, permalink, media) are enumerated. The caveat that this read alone does not establish advertising eligibility is a meaningful behavioral limit that no annotation conveys.

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

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

Three tight sentences: purpose and return shape first, then the postId path, then the exclusions. Every clause carries information; nothing is padded or restated from the 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?

Read-only list tool with full parameter documentation, an output schema, and rich safety annotations. The description covers auth source, return contents, scope exclusions and a key limitation, leaving nothing an agent needs before calling 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 pageId, limit, cursor and postId are already documented with patterns and bounds. The description only adds the preflight use case for postId and does not clarify cursor/limit interaction or what happens when postId is supplied alongside pagination; 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?

Specific verb+resource ('Read published Facebook Page posts') with an explicit scope boundary: no Instagram media, comments, likes or insights, and no ad-eligibility determination. An agent can distinguish this from meta_get_organic_content_enrichment or meta_get_instagram_accounts without opening the schema.

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?

'Use postId for an exact existing-post ad preflight' gives a concrete use case, and the negative scoping sentence rules out using this read to establish advertising eligibility. It stops short of naming a sibling to use instead for Instagram content or insights, so it is clear context rather than a full when/when-not/alternative map.

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, non-destructive and open-world, so the safety profile is free. The description still adds real value beyond that by disclosing that results are limited to pages the caller can access and that linked Instagram references appear only 'when available' — a conditional-field behavior not visible in 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?

One sentence, front-loaded with the action and resource, followed by the returned fields. Nothing is repeated from annotations and nothing is 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?

An output schema exists, so return values needn't be explained, and pagination is covered by the cursor/limit schema descriptions. The remaining gap is small: the description doesn't state that results may be empty when the token manages no pages, nor how the permission scope is determined.

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 already fully documented in the schema, including the businessId vs /me/accounts distinction. The description adds no parameter guidance of its own, which is the expected baseline when the schema carries the burden.

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

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

Specific verb (List) plus specific resource (Facebook Pages) plus an enumeration of returned fields, which separates it from siblings like meta_get_page_posts or meta_get_instagram_accounts. It stops short of naming a sibling or scope boundary explicitly, so it is clear but not fully differentiated.

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

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

Usage is only implied: the word 'accessible' signals that results are permission-scoped to the token's pages, and the fields hint at discovery/selection use. There is no explicit when-to-use statement, no mention of when to prefer meta_get_instagram_accounts or meta_get_business_assets, and no note about when to supply businessId.

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, non-destructive behavior, so the description's real contribution is the disclosure that permission-limited edges yield actionable warnings rather than failing outright — a genuinely useful non-obvious trait. It stops short of covering pagination limits or empty-result 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?

A single front-loaded sentence with no filler; the scope constraint and behavioral caveat both earn their place. Minor awkwardness in the trailing 'when accessible' clause keeps it off a 5.

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

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

With an output schema, full annotation coverage, and 100% schema descriptions, the description only needs to add routing and permission nuance, which it does. An agent could call it correctly from this definition.

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 all five parameters are already documented, and the description only lightly implies that businessId targets Business Manager pixels/datasets while adAccountId targets /adspixels. Baseline 3 applies since the schema does the heavy lifting.

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

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

States a specific verb ('List') and resources ('pixels and datasets') and scopes them to an ad account or Business Manager. It is clearly distinguishable from the sibling tools, none of which deal with pixels, though it does not explicitly name a 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?

'When accessible' hints at a permission precondition but gives no explicit when-to-use/when-not guidance, and nothing tells the agent how to choose between businessId and adAccountId. Usage is implied rather than stated.

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

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

Annotations already declare readOnlyHint=true, idempotentHint=true, and destructiveHint=false, so the trailing 'Read-only' is redundant. The description adds no behavioral context beyond safety (no pagination, no scoping caveats, no behavior when no promotable apps exist), so it earns partial credit only for framing this as a discovery/prep step.

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 densely packed sentence front-loads purpose and then supplies the consuming field path. No filler, though the embedded Graph API field syntax makes it heavier to parse than necessary for an agent skimming it.

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?

An output schema exists, so return values needn't be explained, and the description covers purpose, downstream consumption, and read-only nature. Minor gaps remain around result volume/pagination and empty-result handling for a simple single-parameter listing tool.

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

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

Schema coverage is 100% and the adAccountId description already warns against substituting campaign or business IDs. The description adds nothing about the single parameter, 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?

States a specific verb and resource ('List the apps this ad account can advertise') plus a distinguishing payload ('with their store URLs'). This clearly separates it from asset-listing siblings like meta_get_pages, meta_get_pixels, 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?

Explicitly ties the tool to a concrete downstream use case: setting up a website and app (cross-channel) ad set via promoted_object.omnichannel_object.app[]. It does not name any alternative tool or a when-not-to-use condition, which keeps it short of a 5.

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

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

Annotations already declare readOnlyHint=true, idempotentHint=true, destructiveHint=false and openWorldHint=true, so the safety profile is fully covered and the description does not contradict it. The description adds only a partial view of what is returned (objectives, cells, lift results), with no mention of permissions, scoping to an ad account, data freshness, or error behavior for an invalid study ID.

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

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

Two short sentences with the capability stated first and the return contents second; no filler. The second sentence slightly overlaps the existing output schema, so it earns only partial credit, but the description is appropriately sized.

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

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

With a single well-documented parameter, full annotation coverage and an output schema, the description needs only to say what the tool fetches, which it does. The remaining gap is sibling differentiation in a crowded namespace containing meta_get_ad_studies and meta_interpret_experiment_results, which could lead an agent to pick the wrong tool.

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

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

There is a single parameter, studyId, at 100% schema description coverage ('The Ad Study ID'), so the schema already carries its meaning. The description adds nothing about ID format, provenance (where to obtain the ID), or whether the study must belong to the current ad account. Baseline 3 applies when the schema does the work.

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

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

States a specific verb ('Get') plus resource ('detailed results') and narrows scope to conversion lift or A/B test studies, and lists the result sections (objectives, cells, lift results). An agent can tell it retrieves results rather than study metadata. However, it never names the closely related siblings meta_get_ad_studies (list studies) or meta_interpret_experiment_results, leaving the boundary implicit.

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 only implied: it applies to conversion lift and A/B test studies, so an agent can infer it needs a studyId from an existing study. There is no explicit when-to-use, no prerequisite (e.g. must first call meta_get_ad_studies to obtain an ID), and no guidance on when to prefer meta_interpret_experiment_results instead.

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 still adds real behavioral context beyond that: lookups are 'bounded pagination', the scope is the account library, and 'not_found is not success' warns that a negative result is not proof of absence. Only the fallback mechanism is left opaque.

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, no filler, and the verification intent plus the failure-semantics warning are front-loaded. The only wasted content is the title-based lookup advice, which does not correspond to any input the tool accepts.

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?

An output schema exists, so return values need not be explained, and the description covers membership/readiness semantics and pagination bound. The gap is the instructed fallback: an agent told to 'use the video title to narrow the account-scoped lookup' has only videoId and adAccountId available, leaving the recovery path unexplained and potentially unexecutable.

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 parameters are already documented and the baseline is 3. The description reinforces account scoping ('the selected account library', 'account-scoped lookup'), but it also references a 'video title' narrowing path for which no parameter exists, which muddies rather than clarifies parameter usage.

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 frames the tool as a verification step ('Check video processing and membership in the selected account library') rather than plainly stating it fetches an uploaded video record by ID, so the primary action must be inferred. It does distinguish itself from list-oriented siblings like meta_list_ad_videos by emphasizing per-ID membership/readiness checks, but the framing is oblique.

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 situational cues ('If the first page misses the ID...', 'A direct video read alone never proves membership or readiness') that imply when this verification is needed, which is more than nothing. However, it never names the sibling tools an agent should consider instead (meta_list_ad_videos, meta_get_video_sources), and the advised fallback path is not actionable given the parameters.

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

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

Annotations already declare readOnly, idempotent, openWorld, and non-destructive behavior. The description adds important context beyond annotations by explaining that returned URLs are signed and short-lived, which directly affects how the agent should sequence the call.

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 tightly written sentences front-load the core action and follow with the critical operational constraint. Every clause earns its place.

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

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

With rich annotations, full schema coverage, and an output schema, the description supplies the key missing behavioral context: these URLs are signed and expire quickly. Nothing essential for correct invocation is absent.

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

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

Schema description coverage is 100%, so the input schema already documents adAccountId, videoIds, and pageId thoroughly. The description reinforces the video-specific download use case but does not add parameter-level semantics beyond what the schema provides.

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

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

The description states a specific verb and resource: resolve fresh download URLs (source) and thumbnails for specific ad videos. It is clear enough to distinguish from listing or uploading videos, though it does not explicitly name a sibling tool as the alternative.

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 clear timing guidance: call this at download time because the returned URLs are signed and expire quickly. This is strong contextual usage guidance, though it does not explicitly say when not to use it or name alternatives.

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

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

Annotations already declare readOnly, idempotent, and non-destructive, so the safety profile is covered. The description adds genuine context beyond that: it never exposes the access token, unresolved checks stay 'unknown', and granted scopes do not prove app access level or Meta security clearance — a meaningful reliability caveat an agent would not infer from annotations alone.

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 front-loaded sentences, with the read-only diagnostic purpose stated first and the caveats second. Dense but every clause carries signal; the caveat sentence is slightly packed but not padded.

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?

An output schema exists, so return structure needn't be explained. For a parameterless diagnostic, the description supplies the only genuinely needed extras — the non-exposure guarantee and the limits of what a passing check proves — leaving nothing an agent must guess.

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 takes zero parameters, so the baseline of 4 applies; there is nothing for the description to disambiguate at the argument level.

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

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

States a specific verb and resource ('Read-only connection diagnostic') and enumerates exactly what it inspects: token identity, granted permissions, and accessible ad accounts. This cleanly distinguishes it from data-fetching siblings like meta_get_business_assets and from the seeming overlap with meta_debug_token by framing it as a connection health probe.

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 framing as a 'connection diagnostic' implies usage (verify a connection before running other calls), but it never explicitly says when to choose this over meta_debug_token or meta_list_ad_accounts, which overlap functionally. The caveats about unknown checks imply a pre-flight role without stating it.

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

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

Annotations already declare readOnlyHint, idempotentHint, destructiveHint=false, and openWorldHint, so the safety profile is covered. The description adds that interpretation includes confidence guardrails and cell/objective breakdowns, but it doesn't explain what 'confidence guardrails' means operationally, what happens if a study lacks significance, or how discovery via adAccountId differs from a direct studyId read.

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 that packs the verb, resource, and scope without filler. It is slightly dense ('confidence guardrails, cells, objectives, and optional cell entities') but nothing is redundant.

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?

An output schema exists so return values needn't be described, and annotations cover safety. What remains missing is routing guidance against the closely related meta_get_study_results and any note on study-state prerequisites, which matters for a tool that must interpret rather than merely fetch.

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

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

Schema description coverage is 100%, so parameter meaning is already fully documented, and no param is described in more depth here. The description's mention of 'cells' and 'optional cell entities' loosely echoes cellEntityType/includeCellEntities but adds no new semantics, 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 pair ('read and interpret') on a specific resource ('A/B test or conversion lift study results') and names the dimensions covered (confidence guardrails, cells, objectives, cell entities). It is clear what the tool does, though it does not explicitly distinguish itself from the very similar sibling meta_get_study_results ('interpret' vs 'get' is only implied).

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 only implied: 'interpret' suggests this is the analytical layer over raw study results, but the description never says when to call this versus meta_get_study_results or meta_get_ad_studies, nor when to prefer one over the other. No exclusions or prerequisites (e.g., that a study must have run to completion) are stated.

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

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

Annotations already declare readOnly, idempotent, non-destructive and open-world, so the safety profile is covered. The description adds real behavioral context beyond that: the catalog join is opportunistic and degrades gracefully when catalog access is unavailable, which tells the agent rows may come back unenriched. It does not mention rate limits or pagination, but those live in the schema.

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

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

A single sentence, front-loaded with the primary verb and resource, then the conditional enrichment clause. No filler, no restatement of the title.

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?

An output schema exists, so return values need no explanation, and nine parameters are fully documented in the schema. The description covers the one thing the schema cannot convey — that catalog enrichment is conditional — leaving only minor gaps such as default date-preset behavior and metric/dimension compatibility.

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 enums, defaults, bounds and nested timeRange all documented inline, so the baseline is 3. The description adds no syntax or format guidance for catalogId, productBreakdown, or catalogProductLimit beyond what the schema already states.

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

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

The description states a specific verb and resource ('query product-breakdown insights') plus a secondary behavior ('enrich rows with Product Catalog metadata'), which clearly separates it from the generic meta_get_insights sibling. It stops short of naming an alternative tool, but the 'product-breakdown' scoping makes the domain unmistakable.

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

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

Usage is implied through the product-breakdown framing and the conditional 'when catalog access is available', which signals a prerequisite. However, it never explicitly says to prefer this over meta_get_insights for product-level reporting, nor does it name meta_get_catalog_products as the catalog-side alternative, so routing is left 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, idempotentHint, openWorldHint, and destructiveHint=false, so the safety profile is covered. The description adds useful context about token scope and returned fields, but does not discuss pagination, rate limits, empty results, or permission failures beyond the token reference.

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 followed by the return fields. Every sentence earns its place and there is no redundant or filler language.

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

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

The tool is simple: zero parameters, an output schema exists, and annotations cover the safety profile. The description provides enough context for an agent to know what it does and what it returns, without needing to restate schema or output details.

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

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

The tool has zero parameters, so there are no parameter semantics to explain. The baseline for a zero-parameter schema is 4, and the description does not need to compensate for missing parameter documentation.

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

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

The description states a specific verb and resource: list all Meta ad accounts accessible with the current token. It also names the fields returned, which makes the tool's output concrete. Sibling differentiation is limited: it does not explicitly distinguish itself from tools like meta_get_business_assets or meta_get_account_details.

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

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

Usage is implied by the phrase 'accessible with the current token,' suggesting this is the entry point for discovering accounts. However, there is no explicit when-to-use guidance, no exclusions, and no mention of 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 readOnly, idempotent, non-destructive and openWorld, so the safety bar is met; the description adds genuine operational context beyond that by labeling permalink_url as permanent and publicly served while the CDN URLs are short-lived — a behavioral detail an agent needs for caching decisions. It stops short of mentioning pagination limits, permissions, or 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?

A single front-loaded sentence with no filler, leading with the verb, the resource, and the API path. The trailing field enumeration partly duplicates the output schema, which is minor waste but also the most scannable part of the line.

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, the description need not enumerate return fields, yet it still surfaces the one return detail an agent must act on (permalink stability vs. expiring CDN URLs). Gaps remain around pagination behavior and whether adAccountId must be the act_-prefixed form for this endpoint, though the schema covers the latter.

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

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

Schema coverage is 100%, so the schema already documents all eight parameters including hashes, minWidth/minHeight, nameFilter, cursor, and limit. The description only restates includeUsage in prose ("optionally the creatives using each image") and adds no filtering syntax or matching semantics 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?

States a specific verb and resource ("List the ad account image library (/adimages)") and enumerates the returned fields, so an agent knows exactly what it gets back. It is distinguishable from meta_get_creative_assets and meta_list_ad_videos by resource, but it never names those siblings to confirm the boundary.

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

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

The description gives no when-to-use or when-not-to-use guidance and never routes the agent between this tool and the many sibling listing tools (meta_get_creative_assets, meta_list_ad_videos, meta_get_creatives). The optional includeUsage flag is the only hint about a usage decision, and its trade-off is not explained.

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, non-destructive, and open-world behavior. The description adds useful context beyond the annotations: thumbnails are publicly served in preferred and largest sizes, and source file URLs are returned only on request because they expire quickly.

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 compact sentences with no wasted language. The core identity is front-loaded, and the thumbnail and source-URL details are appropriately secondary.

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 rich annotations, 100% schema coverage, and an output schema, the description covers the essential behavior an agent needs to call the tool correctly. It could still be slightly more complete by mentioning pagination or when to prefer sibling video-source tools, but it is adequate for this list operation.

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

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

Schema description coverage is 100%, so the schema already documents all seven parameters, including limit, cursor, filters, and includeSource. The description adds behavioral meaning for includeSource by explaining why source URLs are opt-in, but it does not deepen semantics for the remaining parameters beyond what the schema 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 clearly states a specific verb and resource: listing the ad account video library (/advideos), and it enumerates the returned fields. It is distinguishable from image-list siblings by its explicit video focus, but it does not directly name or contrast with likely alternatives such as meta_get_video_sources or meta_get_uploaded_video.

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 by describing what the tool lists, but it gives no explicit when-to-use guidance, no exclusions, and no alternatives. It does not tell the agent when to choose this tool over sibling tools such as meta_get_video_sources or meta_list_ad_images.

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=true, idempotent=true, destructive=false, openWorld=true, so the safety profile is covered. The description adds useful traits: the edge allowlist and 'flat fields' (i.e., no nested expansion), plus cursor pagination. It does not mention rate limits, error modes, or what the allowlist rejects.

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, zero filler, with the capability statement first and the routing guidance second. Nothing to trim.

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?

Output schema exists, so return values need no explanation, and the schema fully covers the 11 parameters including the blocked-parameter constraints. For a generic escape-hatch tool this is nearly complete; only guidance on which edges pair with which parentId types is absent.

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 every parameter (edge, parentId, fields, filtering, parameters, cursors, since/until) is documented in the schema. The description only restates the categories of input without adding format details, so baseline 3 applies.

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

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

Specific verb+resource: 'List an allowlisted read-only Meta Graph edge' paired with the field/filter/pagination capabilities. It distinguishes itself from the specialized siblings by framing itself as the generic discovery path, though the term 'edge' remains jargon that only the schema enum fully disambiguates.

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

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

Explicitly says when to use it ('broad metadata/entity discovery when a specialized tool does not expose a newly added field'), which implicitly tells the agent to prefer specialized tools first. No explicit when-not or named alternative, so it falls short of the top band.

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, openWorldHint, and destructiveHint=false, covering the safety profile. The description adds account scoping and name-based search context but does not disclose rate limits, result behavior, pagination implications, or status-filter semantics beyond what structured fields provide.

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 purpose front-loaded and a brief usage note. There is no redundant or filler content.

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

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

An output schema exists and the input schema richly documents pagination, limits, enums, and status-filter nuances, so the description need not repeat those. It gives the core scope and search intent, though it omits routing guidance versus the sibling get/list 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%, with all six parameters documented, including enum values and the statusFilter caveat about native effective_status. The description only restates that entities are searched by name and type, adding no extra parameter meaning such as case sensitivity or exact-match behavior.

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

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

The description states a specific verb ('Search') and resources (campaigns, ad sets, ads), scoped to an ad account and by name. It does not explicitly distinguish this search behavior from sibling list/get tools such as meta_get_campaigns or meta_get_ads, 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?

It gives an implied usage context with 'Useful for finding specific entities,' suggesting use when a name is known. It provides no explicit when-not guidance, alternatives, or notes about pagination versus list-style 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, idempotentHint, openWorldHint, and destructiveHint=false, so the safety profile is fully covered. The description mostly repeats the read-only nature and lists resource categories rather than adding behavioral context such as pagination limits, rate limits, or empty-result behavior. With annotations carrying the behavioral burden, this is a limited contribution.

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 begins with the action and resource. It is efficient and avoids low-value filler, though the enumerated list is somewhat long and could have been structured as use-case guidance instead.

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?

An output schema exists and schema coverage is 100%, so return values and parameters need not be fully explained in prose. However, the description does not help an agent choose among the 17 type enum values or between this and sibling search tools, leaving a meaningful gap for a tool with such a large enum.

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 five parameters are already documented in the input schema. The description hints at categories that map to the type enum, but it does not explain how to use query, countryCode, locationTypes, or limit beyond what the schema already states. Baseline 3 applies 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 uses a specific verb and resource ('Search Meta's read-only targeting metadata') and enumerates several domains such as interests, geographies, locales, and postal codes. It is clear what the tool returns in broad terms, though it does not explicitly distinguish itself from the closely named sibling 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 description implies usage by listing targeting categories, but it never says when to choose this tool over meta_search_entities or other search siblings, nor when not to use it. There is no explicit guidance on prerequisites, required query text, or which targeting type to select for a given task.

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, destructiveHint=false and openWorldHint, so the safety profile is covered. The description adds that it returns errors and warnings and is a pre-flight check, but doesn't explain what distinguishes errors from warnings or whether validation is exhaustive. With annotations carrying the burden, this is adequate but thin.

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

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

Three short sentences with the pre-execution constraint front-loaded; every sentence is relevant. The final sentence is slightly redundant with the first, but there is no bloat.

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 rich annotations, the description needn't explain return values. It covers what the tool validates and when to use it, which is enough for a simple three-parameter dry-run validator; only a hint about the level parameter or error/warning semantics 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 metrics, breakdowns and level. The description only echoes the metric/breakdown combination and says nothing about the level parameter or value formats, so it adds little beyond the schema. 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?

States a specific verb and resource ('Validate a metric/breakdown combination') and makes the pre-execution scope explicit, which separates it from the execution-oriented sibling tools like meta_get_insights. It stops short of naming the sibling it complements, so it's clear but not fully differentiated.

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