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

No annotations are provided, so the description carries the full burden of behavioral disclosure. It clearly communicates that this is an inspection operation on the current token and what aspects it examines. It does not explicitly state side effects, but a zero-parameter read-only token check is well-scoped by the wording.

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 wasted words. The first sentence states the operation and result, and the second sentence gives the use case. Information is front-loaded and easy to parse.

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

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

For a zero-parameter diagnostic tool with no output schema, the description is complete: it states what is checked, that it concerns the current token, and when it is useful. Nothing essential is missing for selection and invocation.

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

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

There are zero parameters, so no parameter documentation is needed. The description adds the useful context that the tool operates on the 'current' access token, which is a value the agent does not need to supply.

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

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

The description uses a specific verb ('Check') with a clear resource ('current access token') and names the exact attributes checked: validity, expiration, and granted scopes. It also frames the tool diagnostically, which distinguishes it from sibling tools like meta_health_check.

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

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

The description explicitly states the intended use case: 'diagnosing auth issues.' It does not name alternative tools or give exclusion criteria, but the purpose is clear enough that an agent can decide when to invoke it.

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

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

No annotations are provided, so the description carries the full burden of conveying safety and behavior. The verb 'Get' unambiguously marks this as a read-only operation, and the list of fields tells the agent what kind of data to expect. It does not mention permission requirements or failure modes, but for a simple metadata getter the read-only signal is adequate.

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

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

The description is a single, compact sentence that front-loads the operation and then itemizes the key return data. There is no repetition of the tool name, no filler, and every word contributes meaning.

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

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

For a one-parameter getter with no output schema, this description is complete: it states the operation, identifies the required input implicitly, and enumerates the returned fields. An agent has enough information to select and invoke the tool correctly without needing additional context.

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

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

The schema documents the only parameter fully, including the expected format and an example ('act_123456789'). The description adds little beyond the phrase 'specific Meta ad account', which aligns with the adAccountId parameter but does not provide additional format or usage detail. With 100% schema coverage, the baseline of 3 is appropriate.

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

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

The description uses a specific verb ('Get') with a clear resource ('Meta ad account') and enumerates the details returned (name, currency, timezone, spend cap, status, business info). The qualifier 'specific' distinguishes this from sibling meta_list_ad_accounts, making the tool's purpose unambiguous.

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

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

The description clearly signals that this tool is for a single account rather than for listing accounts, which gives the agent a clear context for when to use it. It does not explicitly name alternatives or say when not to use it, but the specific-vs-list contrast is sufficient to route an agent correctly.

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

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

No annotations are provided, so the description carries full responsibility for behavioral disclosure. It does indicate this is a read operation and lists output fields, but says nothing about pagination, time filtering, response shape, rate limits, or auth requirements. This leaves meaningful behavioral gaps.

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

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

The description is a single front-loaded sentence that names the endpoint, the resource, and the returned fields without wasted words. It is concise and easy to scan.

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 listing tool with a rich parameter schema and no output schema, the description provides enough context: the endpoint, the resource, and the return fields. It could be improved with an explicit note about pagination via cursor, but this is largely inferable from the schema.

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

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

Schema description coverage is 80%, so the schema already documents most parameters including since, until, cursor, and adAccountId. The description adds no additional parameter semantics, which is acceptable given the schema's coverage.

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

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

The description clearly identifies a specific resource (ad account activity logs) and the endpoint path, and lists the returned fields. It is distinguishable from all sibling tools, none of which mention 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 makes the use case clear: retrieve ad account activity logs. It does not explicitly discuss alternatives or exclusions, but the context is strong enough that an agent can infer when this tool is appropriate.

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

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

No annotations are provided, so the description carries the full burden of behavioral disclosure. It explicitly states the operation is read-only and 'never creates or edits a creative,' and it discloses that the response may contain an iframe body. It does not cover auth, rate limits, or failure modes, but the key safety and response-shape behaviors are disclosed.

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

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

The description is a single well-structured sentence that front-loads the core action and read-only guarantee. Every clause adds useful information, with no filler or repetition.

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

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

For a simple two-parameter read-only tool with no output schema, the description provides essential context: what is returned (preview markup), a possible response detail (iframe body), and the non-mutating nature. It does not address permissions or error conditions, but the core information an agent needs to safely invoke the tool is present.

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 0%, so the description must compensate. It maps adId to 'existing Meta ad' and adFormat to 'requested placement format,' which adds conceptual meaning beyond the raw schema. However, it does not provide examples, allowed format values, or further guidance on how to supply the parameters.

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

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

The description opens with a specific action and resource: 'Get the read-only preview markup for an existing Meta ad in a requested placement format.' This clearly distinguishes the tool from sibling get_* tools by focusing on rendered preview markup rather than raw creatives, assets, or analytics.

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

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

The description implies the tool is for fetching a preview of an existing ad in a specific placement format, but it does not explicitly say when to use this tool versus alternatives like meta_get_creatives or meta_get_creative_assets. No exclusions or sibling comparisons are provided.

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

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

There are no annotations, so the description carries the behavioral transparency burden. It does disclose the read-only nature via 'List' and the output fields, but it does not mention pagination behavior, the effect of the cursor/limit parameters, or what the default status filter is when statusFilter is omitted.

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

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

The description is two concise sentences with no filler. The main action and resource are front-loaded, and the second sentence directly states the return fields, making it easy to scan.

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

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

For a read-only list tool with five parameters and no output schema, the description covers the essential purpose, filter behavior, and return fields. The schema fills in pagination and parameter details, but a short note about pagination or default status behavior would make it fully self-sufficient.

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

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

Schema description coverage is 80%, so the schema already documents most parameters. The description adds meaningful context only for the ad set filter and the returned status field, but it does not enrich limit, cursor, or statusFilter 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 action ('List ads'), a specific resource ('Meta ad account'), and the optional filter ('by ad set'), which distinguishes it from siblings like meta_get_adsets and meta_get_campaigns. It also enumerates exactly what is returned, leaving no ambiguity about the tool's primary function.

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

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

No guidance is given about when to choose this tool over its alternatives, such as meta_get_adsets, meta_get_campaigns, or meta_get_creatives. The description implies a listing use case but never states exclusions or conditions like 'use this for ads, not ad sets'.

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?

There are no annotations, so the description carries the burden of behavioral disclosure. It does reveal the kind of data returned (targeting, budget, optimization, schedule), which is helpful. However, it does not mention pagination behavior, status filtering defaults, or any read-only or rate-limit implications, leaving gaps 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 a single, efficient sentence that front-loads the core action and resource, then adds the optional filter and a concise summary of returned information. Every clause earns its place without redundancy.

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

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

With no output schema, the description helpfully summarizes what the tool returns, which is valuable. Still, it omits practical context such as pagination via cursor, how statusFilter interacts with results, and whether archived/deleted adsets are included by default. For a five-parameter list tool, this is adequate but not fully complete.

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

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

Schema description coverage is 80%, so most parameters are already documented structurally. The description adds minimal parameter meaning beyond mentioning the optional campaign filter, which is already described in the schema. It does not clarify the behavior of limit, cursor, or statusFilter, but the schema covers these sufficiently.

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 for a Meta ad account.' It also clarifies the optional campaign filter, which distinguishes it from sibling tools like meta_get_campaigns and meta_get_ads. The scope is immediately clear.

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

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

The description clearly implies when to use the tool: when you need ad set level details for a Meta ad account, optionally scoped by campaign. It does not explicitly name alternatives or exclusions, but the context is clear enough for an agent to select it over campaign- or ad-level tools.

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

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

No annotations are provided, so the description carries the full burden of behavioral disclosure. 'List' implies a read-only operation, and the description usefully states the output includes study type, status, and cells. However, it does not disclose pagination behavior, result limits, or any account-level requirements, which would strengthen transparency.

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

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

The description is a single concise sentence that front-loads the primary action and resource, then adds the key output details. Every word contributes meaning, with no redundant phrasing or filler.

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

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

For a one-parameter list tool with no output schema, the description is largely complete: it states the resource, scope, and meaningful output fields. It lacks explicit mention of pagination or relationship to study results, but these are not critical for a straightforward 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?

The only parameter, adAccountId, is fully described in the schema with an example format ('act_123456789'). Since schema description coverage is 100%, the description does not need to add further parameter detail, and it does not attempt to repeat 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 ('List') and identifies the exact resource ('conversion lift studies and A/B tests (Ad Studies)') scoped to an ad account. It also specifies the included fields (study type, status, cells), which clearly distinguishes it from sibling tools like meta_get_study_results that would retrieve study outcomes rather than the study list itself.

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

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

The description provides no guidance on when to use this tool versus alternatives, nor does it mention any exclusions or prerequisites. It simply states what the tool does, leaving the agent to infer appropriate usage from the tool name and sibling list alone.

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

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

The description clearly signals a read-only operation and notes that results depend on permissions, which adds useful behavioral context. However, with no annotations and no output schema, it omits details about pagination behavior, error conditions, or what 'rich fields' are actually returned, leaving only a partial transparency picture.

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

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

The description is a single, front-loaded sentence that wastes no words. It efficiently conveys the core action, target audiences, and key features, though phrases like 'rich fields' and 'where permissions allow' are somewhat vague.

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

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

This is a moderately complex tool with five parameters, no output schema, and no annotations, yet the description does not explain what 'detailed' or 'rich fields' means, when to pass audienceIds versus adAccountId, or how this relates to meta_get_audiences. An agent would still need to infer important invocation 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 schema already describes cursor, adAccountId, and audienceIds (60% coverage), and the description adds useful context by mapping the type enum to audience categories and linking pagination to limit/cursor. It does not, however, clarify the relationship between adAccountId and audienceIds or add semantics beyond what the schema already provides.

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

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

The description uses a specific verb ('Read') and a specific resource ('detailed custom, saved, and lookalike audiences'), making the main purpose clear. It also mentions pagination and rich fields, but it does not explicitly differentiate itself from the sibling meta_get_audiences other than by the word 'detailed'.

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

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

There is no guidance on when to use this tool versus alternatives like meta_get_audiences, nor any exclusions or conditions. The phrase 'where permissions allow' hints at permission constraints but does not explain when this tool is preferable or how to choose between its own listing vs. batch-ID modes.

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

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

With no annotations, the description carries the full burden. It implies a read-only listing operation, which is useful, but it does not disclose pagination behavior, response format, rate limits, or how the limit parameter affects results. Minimal behavioral context beyond the verb 'List'.

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

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

A single sentence with no filler, front-loaded with the action and resource. It is appropriately sized for the tool's simplicity.

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 list tool with no output schema and no annotations, the description should provide more context about return shape and pagination. The current text plus input schema covers only the basic invocation; an agent still lacks enough information to anticipate the result or handle large result sets well.

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

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

Schema coverage is 67%, but the description adds little beyond the schema. It restates the audience types already in the type enum and does not explain limit or adAccountId beyond what the schema provides. The limit parameter remains semantically underdocumented.

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 action ('List'), a resource ('audiences'), and a scope ('Meta ad account'). It also names the three audience types covered, making the core purpose clear. It does not explicitly contrast with sibling meta_get_audience_details, so the distinction is left to inference.

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

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

No guidance is given about when to use this tool versus alternatives such as meta_get_audience_details. The only implied context is 'when you need to list audiences,' but no exclusions or sibling comparisons are provided.

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

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

There are no annotations, so the description must carry the full behavioral burden. The 'Read' verb implies non-mutating behavior and the mention of optional block-list edges gives a hint about sources, but the description does not state read-only status explicitly, permissions, pagination behavior, or what 'signals' actually contain. This is thin for a tool with no annotation support.

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

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

The description is a single, front-loaded sentence with no filler. The series 'brand safety, suitability, placement, and context-control signals' is dense but efficiently conveys scope.

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 8 parameters, no annotations, and no output schema, a one-sentence description is not enough. Four parameters have no schema descriptions, and the description does not explain the effect of includeRawTargeting, limit, or the interaction between includeAdsets and includeBlockLists. An agent would need to guess at key invocation 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 50%, so the description should compensate. It does add context by mentioning ad account/ad set targeting and optional block-list edges, which helps interpret includeAdsets and includeBlockLists. However, it does not clarify includeRawTargeting or limit, leaving the schema coverage gap only partially filled.

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 'Read' and clearly identifies the resource: brand safety, suitability, placement, and context-control signals from ad account/ad set targeting and optional block-list edges. This distinguishes it from most siblings like meta_get_campaigns or meta_get_insights, 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 description implies the use case: use when you need brand safety or suitability information. However, it provides no explicit when-to-use or when-not-to-use guidance and does not mention alternatives, so an agent must infer selection from the tool name and topic rather than from clear routing instructions.

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

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

There are no annotations, so the description carries the full burden; it does disclose the key safety trait 'read-only' and conditions results on permissions. However, it does not mention pagination, rate limits, authentication requirements, or how partial access is reported, which would be valuable for this unannotated read tool.

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

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

A single compact sentence that front-loads the action and scope, enumerates the covered assets, and conveys the read-only, permission-dependent nature. No filler or redundancy.

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

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

With no output schema and no annotations, the description should specify the response shape, pagination semantics, and failure/permission-denied behavior, but it does not. An agent is left to infer how limit and cursor affect results and what the returned business/page/Instagram/pixel/dataset records look like.

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 75%, so the baseline is 3; cursor, businessId, and adAccountId already have descriptions in the schema. The description lists asset types but does not clarify how limit applies (per asset type vs. total) or how the parameters select among businesses/pages/pixels/datasets, so it adds little 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?

States a clear verb ('Discover'), a resource ('Meta Business assets'), and enumerates the asset types covered (businesses, pages, Instagram accounts, pixels, datasets), so an agent knows what the tool returns. It does not explicitly contrast itself with sibling tools like meta_get_pages or meta_get_pixels, so it stops short of full sibling differentiation.

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

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

The phrase 'Discover accessible ... when permissions allow' implies a discovery/access-checking use case and notes the permission prerequisite. It provides no explicit guidance on when to choose this aggregate tool over the specialized per-asset sibling tools or what conditions would make a sibling preferable.

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

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

With no annotations provided, the description carries the full burden of behavioral disclosure. It states the return fields (ID, name, status, objective, budget, bid strategy), which is useful, but doesn't mention pagination behavior, whether deleted/archived campaigns are included by default, or potential side effects (though 'List' implies non-destructive). The behavior is partially disclosed but not comprehensively.

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

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

The description is a single sentence that front-loads the action and resource, followed by a concise list of return fields. Every word earns its place, with no filler or redundancy.

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

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

The description is adequate for a simple list operation, but gaps remain: no usage guidance versus sibling tools, no mention of pagination despite the cursor parameter, and no output schema to clarify the exact response shape. The return-field list helps, but the tool would benefit from stating when to use it instead of meta_get_campaign_structure or meta_get_adsets.

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 75%, so most parameters (adAccountId, cursor, statusFilter) are explained in the schema. The description adds no parameter-level meaning beyond the schema, and the one uncovered parameter (limit) has self-explanatory default/min/max values. This is adequate but not enhanced.

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

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

The description states a specific verb ('List'), resource ('campaigns'), and scope ('for a Meta ad account'), making the tool's function clear. It does not explicitly distinguish this tool from siblings like meta_get_campaign_structure, but the purpose is unambiguous enough for initial selection.

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

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

No guidance is given on when to use this tool versus alternatives. The description only states what the tool does, leaving the agent to infer that this is the go-to for listing campaigns. It neither names alternative tools nor mentions conditions or exclusions.

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

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

With no annotations, the description carries the behavioral disclosure burden. It does disclose the return shape ('campaigns -> ad sets -> ads') and implies read-only behavior with 'Get'. However, it does not mention pagination, the effect of optional campaignId, or what fields each node contains, leaving notable gaps.

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

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

A single sentence with no filler: it front-loads the action and object, gives a compact hierarchy definition, and ends with a brief usage cue. Every clause adds value.

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

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

For a read-only structure tool with only two simple parameters, the description plus full schema coverage is sufficient for invocation and high-level return expectations. The optional campaignId behavior is documented in the schema. A little more detail on node fields would help, but the arrows communicate the essential shape.

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 'adAccountId' and 'campaignId' are already documented in the schema. The description adds no parameter-specific meaning, 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 uses a specific verb 'Get', names the resource 'hierarchical campaign structure', and defines the hierarchy as campaigns -> ad sets -> ads. This clearly differentiates it from sibling tools like meta_get_campaigns, meta_get_adsets, and meta_get_ads, which focus on a single level.

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

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

The phrase 'Useful for understanding account organization' provides clear context for when to use this tool. It does not explicitly name alternatives or exclusions, but the hierarchy framing implies it is for multi-level structure rather than single-level list retrieval.

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

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

No annotations are present, so the description carries the burden of disclosing side effects. It clearly states 'Read' and 'without creating or updating catalog assets', making the non-mutating nature explicit. It does not fully describe pagination or error behavior, but those are partly inferable from the schema.

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

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

The description is two compact sentences with no filler. The core read/lookup purpose is front-loaded, and the safety guarantee 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 tool with 8 optional parameters and no output schema, the description covers the broad purpose and non-mutation but does not describe the response shape beyond 'join-ready product metadata' or explicitly route to related sibling tools. Parameter descriptions fill many gaps, but some usage context remains implicit.

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

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

Schema description coverage is high at roughly 88%, and the schema already documents most parameters such as search, catalogId, businessId, productIds, and includeProducts. The description adds no direct parameter-level detail, so it stays at the baseline for schema-covered parameters.

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

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

The description uses an explicit verb, 'Read', and identifies the exact resource: Product Catalogs and Product Items. It also distinguishes itself from mutating tools by stating it does not create or update catalog assets.

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

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

The description gives a clear context: use this when catalog access is available and you need product metadata. It does not explicitly name sibling alternatives such as meta_get_business_assets or meta_join_product_insights, so it stops short of full when-not/alternative routing.

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

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

No annotations are provided, so the description carries the behavioral disclosure burden. It discloses that the output is normalized and lists the returned fields, and 'Return' implies a read operation. However, it does not mention pagination/cursor behavior, permission requirements, or what happens if no identifier parameter is supplied.

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

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

The description is a single dense sentence with the action and resource front-loaded, followed by a colon-delimited list of output fields. Every phrase adds information and 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?

The description plus schema covers the main input and output fields, but with no output schema and zero required parameters, the agent must infer that at least one identifier (adIds, creativeIds, or adAccountId) is necessary. Response envelope and pagination details are also left underspecified.

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 high at 80%, so the baseline is 3. The description adds little parameter semantics beyond the schema; 'for ads or creative IDs' merely restates the adIds/creativeIds properties, and it does not enrich the meaning of limit, cursor, or adAccountId.

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

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

The description opens with a specific verb and resource: 'Return normalized creative asset metadata,' and then enumerates the returned fields, making the tool's function clear. It does not reach 5 because it never contrasts this tool with the closely named sibling meta_get_creatives, so the agent must infer the distinction from the word 'assets'.

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

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

The description gives clear context: use this tool when you need normalized asset metadata for ad IDs or creative IDs. It does not explicitly name alternatives or state when not to use it, but the context is specific enough for an agent to route a matching request.

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

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

No annotations are provided, so the description carries the full burden of behavioral disclosure. It indicates a read operation and lists content types, but it does not disclose that adIds is optional, how scope changes when adIds is omitted, whether pagination or limit behavior applies, or what permissions are required. The phrase 'for specified ads' is potentially misleading given adIds is not 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?

The description is short and front-loaded, with the main verb and content types appearing early. The second sentence is somewhat redundant with the first ('creative content' vs 'creative details'), but overall there is no wasted text.

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

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

For a tool with three parameters, no output schema, and no annotations, this description is incomplete. It does not explain what happens when adIds is omitted, how limit and pagination work, what the exact return structure looks like, or any authentication/scoping constraints. An agent could easily invoke it with incorrect assumptions about scope.

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

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

The input schema already documents adAccountId and adIds, and the description adds no parameter-level meaning beyond that. The limit parameter has no description in the schema, and the description does not compensate by explaining its behavior. Since schema coverage is only 67%, the description should have added clarification but does not.

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

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

The description clearly states the verb and resource: 'Get ad creative content' and lists the content types returned (text, images, videos, links, call-to-action). It also clarifies that it returns details for specified ads. However, it does not explicitly distinguish itself from the similarly named sibling meta_get_creative_assets, 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?

The description provides no guidance on when to use this tool versus alternatives like meta_get_creative_assets or other ad-related tools. 'For specified ads' implies the tool needs ad IDs, but there is no explicit statement of when to choose it, what prerequisites exist, or which tools to prefer in other scenarios.

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

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

With no annotations, the description carries the burden of behavioral disclosure. It does usefully state that the operation is 'read-only' and that fields like status/effective_status/issues_info are used 'where available.' However, it does not disclose pagination behavior, rate limits, response shape, or what 'simple delivery insights' includes beyond the schema.

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

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

The description is a single dense sentence that front-loads the core purpose and avoids filler. Every phrase contributes meaning, and it remains readable despite combining scope, data source, and read-only behavior.

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

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

The description plus a fairly rich schema provides enough for basic invocation, but there is no output schema and the description does not describe the return structure or how diagnostics are aggregated. Given the tool's complexity and lack of annotations, some important invocation context is still 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 71%, with cursor, timeRange, datePreset, adAccountId, and effectiveStatusFilter already described. The description adds context by mapping levels to campaigns/ad sets/ads and by referencing effective_status/issues_info, but it does not compensate for undocumented parameters like limit and 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?

The description names a specific action ('Aggregate'), a resource ('delivery diagnostics'), and the scope ('across campaigns, ad sets, and ads'). It clearly conveys what the tool does, though it does not explicitly differentiate it from sibling tools such as meta_get_insights or meta_health_check.

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

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

No guidance is given for when to use this tool versus alternatives like meta_get_insights, meta_get_ads, or meta_health_check. The description implies a diagnostics use case but does not state exclusions, prerequisites, or conditions that would route an agent to another sibling.

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 are absent, so the description carries the full disclosure burden. It does reveal a non-obvious behavior: the query planner automatically splits incompatible metric/breakdown combinations into multiple API requests and merges results. However, it does not mention read-only status, authentication, rate limits, pagination, or failure behavior, so transparency is partial.

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 the core purpose and is mostly efficient. However, the two sentences 'Use meta://metrics resource...' and 'Use meta://breakdowns...' repeat information already present in the schema's parameter descriptions, so they do not earn their place as unique additions.

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

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

Given no output schema and no annotations, the description needs to cover return behavior and safe usage more thoroughly. It explains the query planner's merging behavior, but it does not describe the result shape, pagination, or how this tool relates to the raw insights sibling. The high schema coverage compensates partially, but gaps remain.

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 high (88%), so the schema already documents most parameters. The description references meta://metrics and meta://breakdowns, but the schema itself already includes these references in the metrics and breakdowns parameter descriptions. The query planner sentence is behavioral rather than parameter-specific, so the description adds little 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 opens with a specific verb and resource: 'Query Meta Ads performance insights.' It also states the tool supports 170+ metrics and 43+ breakdowns, with an automatic query planner that splits incompatible combinations. This distinguishes it from raw endpoints like meta_get_insights_raw, though it never names an alternative explicitly, 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?

No guidance is provided on when to choose this tool over siblings. It does not mention alternatives, exclusions, or conditions like 'use meta_get_insights_raw if you need unmerged API responses.' The only implied usage is that it queries performance insights, which is not enough to route an agent reliably.

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

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

No annotations are provided, so the description carries the behavioral disclosure burden. It discloses that field names are validated and native/raw, and that pagination is supported, which is useful. However, it does note describe the return shape, pagination details, error behavior, or whether results are passthrough vs transformed, leaving some behavioral uncertainty.

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

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

Two sentences, front-loaded with the action and resource, with the key differentiator in the second sentence. No filler; every clause adds signal in a compact way.

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 complex — 14 parameters, nested objects, and no output schema — yet the description is only a high-level summary. It gives no guidance on how parameters combine, what default behaviors apply, what errors look like, or what the raw response contains, leaving substantial context missing for an agent trying to invoke it correctly.

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

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

Schema description coverage is only 14%, so the description needed to explain the large parameter set. It groups many capabilities (breakdowns, action attribution windows, filters, sort, summary, pagination) into a list, but does not explain any individual parameter's semantics, syntax, or interactions. This adds only minimal meaning beyond the schema.

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

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

The description states a specific verb (Query), a clear resource (the Meta Insights edge), and enumerates supported capabilities (native field names, breakdowns, attribution windows, filters, sort, summary, pagination). It also distinguishes itself from meta_get_insights by positioning itself as the raw-field complement when the curated catalog lags.

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

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

It explicitly says this complements meta_get_insights when Meta adds fields before the curated metric catalog is updated, giving a clear condition for when to choose this tool. It does not explicitly discuss when not to use it or mention other sibling tools, but the primary alternative is 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?

The description discloses that results depend on permissions ('when permissions allow') and that only accessible linked accounts are returned. It does not explicitly state read-only behavior, pagination, rate limits, or authentication requirements. With no annotations provided, the description carries the burden, so partial disclosure earns a middle score.

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?

Single sentence, front-loaded with the verb, and covers the essential scope without filler. Every phrase earns its place and the structure is easy to parse.

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

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

For a 5-parameter tool with no output schema and no annotations, the description is somewhat sparse. It tells the agent what the tool lists and the source options, but not the return shape, pagination behavior, or how the optional parameters interact. This is adequate but not complete.

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

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

Schema coverage is 80% with all parameters except 'limit' documented in the schema. The description adds value by linking the three optional IDs to real-world sources: Pages, Business Manager, and ad account, helping an agent decide which parameter to fill. However, it doesn't clarify whether these parameters are mutually exclusive or can be combined.

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

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

The description states a clear verb ('List') and a specific resource ('Instagram accounts'), further scoped by the source assets (Pages, Business Manager, ad account). This distinguishes it from sibling tools that list other resources like ad accounts or business assets, 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 description implies usage context: use when needing Instagram accounts linked to accessible Pages, Business Manager assets, or an ad account. However, it provides no explicit comparison to siblings, no 'when not to use' guidance, and does not mention prerequisites or exclusions.

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

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

With no annotations, the description carries the full behavioral disclosure burden. It does disclose that the tool is GET-only (read-only) and limited to flat fields on a single node. However, it omits authentication requirements, rate limits, and behavior for invalid or unsupported fields, which are relevant for a Meta Graph escape hatch.

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 action and resource. The second sentence earns its place by explaining the tool's purpose as an escape hatch, which is essential context. 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?

The description covers purpose, scope, and read-only safety, and is sufficient for an agent to decide when to invoke it. It lacks explicit output format and error behavior, but for an arbitrary-fields read tool the output is inherently variable and largely implied by the request. Overall it is adequately complete.

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

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

All three parameters have rich schema descriptions (100% coverage), so the tool description need not add much. It reinforces the 'flat fields' and 'one node' concepts but adds no parameter-specific semantics beyond what the schema already documents. Baseline 3 is appropriate.

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

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

The description opens with a specific verb and resource: 'Read arbitrary flat fields from one Meta Graph node.' It clearly differentiates itself from the many schema-specific sibling tools by framing itself as an 'escape hatch' for newly released fields, so an agent knows exactly what it does and how it differs.

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

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

The description gives clear context for when to use the tool: when a field is newly released and not yet covered by a fixed MCP schema update. It does not explicitly name alternative tools or state when not to use it, such as preferring dedicated endpoints when fields are already supported, so it stops short of a full 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?

There are no annotations, so the description carries the full burden of behavioral disclosure. The phrase 'optional read-only insights' is the only behavioral hint. It does not address whether the whole operation is read-only, what permissions are required, how pagination works, or what happens when IDs are invalid or missing.

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

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

The description is a single compact sentence with useful keywords and no filler. It is easy to parse and front-loads the core purpose, though the brevity comes at the expense of needed details.

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

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

For an 11-parameter, 0-required tool with no annotations and no output schema, this one-liner is insufficient. It omits input-mode selection, pagination behavior, output shape, and usage boundaries, leaving the agent to infer too much from parameter names and sibling tool names.

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 only 64%, and the description adds almost no parameter-level meaning. It vaguely aligns with includeInsights through 'optional read-only insights' but does not clarify the roles of limit, cursor, pageId versus postIds versus mediaIds, or the includePagePosts and includeInstagramMedia toggles. It therefore does not compensate for the undocumented parameters.

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

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

The description names a specific action ('Enrich'), a clear resource scope ('Facebook Page posts and Instagram organic media'), and the kind of data returned (media URLs, permalinks, counts, attachments, insights). It is distinguishable from sibling tools like meta_get_page_posts, but it does not explicitly name an alternative or exclusion, 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?

No when-to-use or when-not-to-use guidance is provided. The description does not mention alternatives such as meta_get_page_posts or meta_get_insights_raw, nor does it state under what conditions an agent should prefer this tool over those. Usage context is only weakly implied by the word 'enrich'.

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

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

With no annotations, the description carries the full behavioral burden. It mentions access requirements but does not disclose pagination, ordering, read-only behavior, limits of 'recent', or what the response contains.

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 brief sentences with no filler. The main action is front-loaded and the access requirement is usefully included.

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

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

For a simple two-parameter read operation, the description is mostly adequate, but it lacks clarity on output shape, pagination, and what 'recent' means. Slightly more detail would make it fully self-contained.

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 50%: pageId is documented, but limit is not. The description does not explain limit behavior or add meaning beyond the schema's default, min, and max values.

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

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

The description states a specific action ('Get recent posts') and a clear resource ('connected Facebook/Instagram page'). It is distinguishable from most sibling tools, though it does not explicitly contrast with any 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?

No guidance is provided on when to use this tool versus alternatives like meta_get_insights or meta_get_pages. 'Requires page access' is a prerequisite, not a usage distinction.

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

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

No annotations are present, so the description carries the full disclosure burden. It does add two behavioral cues beyond the schema: results are filtered to 'accessible' Pages and Instagram references are returned only 'when available' (a conditional-field caveat). However, it never states pagination behavior, the /me/accounts vs businessId execution paths, or explicitly confirms a read-only 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?

One sentence of roughly 20 words with zero filler. It leads with the action verb and resource, then packs the full return-field list and the conditional-Instagram caveat, giving maximum information per word.

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?

Adequate for a simple list endpoint: the schema documents two of three parameters including the critical businessId-vs-/me/accounts distinction, and the description enumerates all return fields in lieu of an output schema. Remaining gaps — pagination mechanics and empty/error behavior — are minor for a low-complexity tool, though the absence of annotations leaves the read-only profile implicit.

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

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

Schema description coverage is 67% — cursor and businessId already carry descriptions, and limit's type/default/min/max make its semantics self-evident. The description adds no parameter meaning, but the gap is minor since the undocumented limit is inferable from its constraints.

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'), a specific resource ('accessible Facebook Pages'), and enumerates the returned fields (id, name, category, tasks, picture, linked Instagram references). This resource is distinct from every sibling tool — none of the 33 siblings target Facebook Page enumeration, so an agent can tell it apart without opening schemas.

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

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

The description implies the use case (enumerate Pages the authenticated identity can access) but gives no explicit when-to-use or when-not-to-use guidance. With 33 siblings including meta_get_business_assets and meta_get_account_details, which may overlap in asset-listing scope, the absence of alternative routing is a noticeable gap.

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

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

With no annotations, the description carries the burden of behavioral disclosure. It goes beyond a simple list action by promising 'actionable warnings for permission-limited edges', which is valuable and non-obvious. It does not mention pagination or output details, but the core partial-access warning behavior is disclosed.

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

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

The description is a single, information-dense sentence that front-loads the primary action and resource, then adds the key behavioral nuance about warnings. No wasted words.

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

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

The description gives the essential scope and a useful output signal, but there is no output schema and no annotations, so more context would help: pagination behavior, how the two ID parameters interact, and when this tool should be preferred over related asset-listing tools. It is adequate but not fully complete.

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

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

Schema description coverage is 80%, so the parameters are mostly self-documenting. The description adds conceptual context by mapping pixels/datasets to ad account or Business Manager, which aligns with adAccountId and businessId, but it does not add meaningful per-parameter 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?

The description clearly states the specific verb 'List' and the resource ('pixels and datasets'), and scopes it to 'an ad account or Business Manager'. This distinguishes it from sibling tools that target other asset types, even without naming 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 description provides clear context for when to use the tool: when listing pixels or datasets from an ad account or Business Manager. It does not explicitly name sibling alternatives or state when not to use it, but the resource focus is specific enough to guide selection.

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

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

With no annotations provided, the description carries the full burden. It does disclose the return content ('objectives, cells, and lift results') and the 'Get' wording implies a read-only operation. However, it does not mention whether results require a completed study, authentication prerequisites, or any availability constraints.

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

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

Two concise sentences with no filler. The primary action is front-loaded and the return contents are stated efficiently. Every sentence earns its place.

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

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

For a simple one-parameter getter with no output schema, the description is reasonably complete: it names the resource, the action, and the key return values. It would be more complete if it noted the relationship to meta_get_ad_studies or meta_interpret_experiment_results, but the core invocation context is clear.

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

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

The input schema already fully describes studyId as 'The Ad Study ID' with 100% coverage, so the description adds only the context that the study is a conversion lift or A/B test. This is adequate but does not provide extra parameter-level meaning beyond the schema.

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

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

The description clearly states the tool gets detailed results for a conversion lift or A/B test study and lists the returned components (objectives, cells, lift results). It distinguishes itself from list-style tools like meta_get_ad_studies, but it does not explicitly differentiate from the closely related meta_interpret_experiment_results 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?

There is no guidance about when to choose this tool instead of alternatives such as meta_get_ad_studies for listing studies or meta_interpret_experiment_results for interpreting results. The only implied usage is 'when you need detailed results,' which largely restates the tool's purpose.

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

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

Annotations are entirely absent, so the description carries the full burden of behavioral disclosure. It explicitly declares the operation read-only and states that it does not expose the access token, which is exactly the safety context an agent needs when deciding to invoke this tool.

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

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

A single sentence front-loads the core identity ('Agent-ready read-only health check') and then compresses all three key behaviors into a tight list. Every phrase earns its place, with no filler or repetition.

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

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

For a zero-parameter, read-only diagnostic tool, the description covers the essential functional scope: validation, account listing, and scope warnings. It does not describe the exact return shape, and with no output schema present that is a minor gap, but complexity is low enough that the description is still substantially complete.

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

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

The input schema has zero parameters, and the baseline for zero-parameter tools is 4. There is nothing additional the description needs to explain about parameter meaning or formatting.

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, agent-relevant verb ('health check') and clearly enumerates three distinct behaviors: validating token metadata, listing accessible ad accounts, and warning about missing read scopes. It differentiates itself from siblings like meta_debug_token and meta_list_ad_accounts by presenting a composite diagnostic scope rather than a single resource operation.

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 'Agent-ready' suggests this is a preliminary setup/verification call, but the description never explicitly says when to use it over sibling tools such as meta_debug_token or meta_list_ad_accounts. No alternatives or exclusions are named, so usage context 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 are absent, so the description carries the full burden of behavioral disclosure. It states that the tool 'reads and interprets' results, suggesting a read-like operation, but it does not explain what 'confidence guardrails' actually do, whether interpretation involves any transformation or side effects, how output is structured, or any rate-limit or permission considerations. Critical behavioral context is missing.

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 introduces the tool's core purpose and key concepts without filler. It could earn a 5 if it also included a brief usage pointer, but as written it is appropriately concise and scannable.

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

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

For a tool with no annotations, no output schema, and a 60% schema-covered parameter set, the description is too thin. It leaves unclear how the tool differs from meta_get_study_results, how the confidence guardrails are computed or applied, what the optional cell entities affect, and what an agent should expect in the response. A competent agent would likely need to inspect the tool implementation or call it speculatively to understand its behavior.

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

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

Schema description coverage is 60%, with studyId, adAccountId, and includeCellEntities documented but limit and cellEntityType left undocumented. The description mentions 'optional cell entities,' which partially relates to includeCellEntities and cellEntityType, but it does not clarify the relationship between adAccountId and studyId, the meaning of cellEntityType, or the limit parameter. It adds only marginal value beyond the schema.

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

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

The description uses a specific verb ('Read and interpret') and names the resource ('A/B test or conversion lift study results'), with additional qualifiers (confidence guardrails, cells, objectives, optional cell entities) that distinguish it from a simple result fetcher like meta_get_study_results. It does not explicitly contrast itself with sibling tools, but the 'interpret' language and study-analysis framing make the purpose reasonably clear.

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

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

No guidance is given about when to use this tool versus alternatives such as meta_get_study_results or meta_get_ad_studies. It does not state prerequisites, whether studyId should be preferred over adAccountId, or when to set includeCellEntities. The usage context must be inferred from the parameter schema rather than explicitly 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?

No annotations are provided, so the description carries the full burden of behavioral disclosure. It says 'Query' and 'enrich', suggesting read-only behavior, but does not explicitly confirm safety, explain what happens when catalog access is unavailable, or describe any limitations, error cases, or rate considerations. The description only hints at a conditional join without detailing the behavior.

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

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

The description is a single concise sentence that front-loads the core action and differentiates the tool. It wastes no words, though it could be slightly more informative without sacrificing brevity. The structure is adequate for a simple tool name and 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?

With no output schema, no annotations, and 9 parameters including a nested timeRange object, the description is too sparse to be complete. It does not mention return format, join behavior, error handling, pagination, or how parameters interact. Agents would need to inspect the schema and sibling tools to infer expected usage and output, which is a significant gap.

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

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

Schema description coverage is only 44%, and the description does not compensate for the undocumented parameters. It vaguely references 'product-breakdown' and 'Product Catalog metadata', which maps to productBreakdown and catalogId, but leaves metrics, level, limit, and catalogProductLimit unexplained. The description adds minimal semantic value over the schema, and with 9 parameters, more guidance is needed.

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 action ('Query product-breakdown insights') and a distinct enrichment behavior ('enrich rows with Product Catalog metadata'), which separates it from sibling tools like meta_get_insights and meta_get_catalog_products. It lacks an explicit counter-reference to a sibling, so it does not fully earn a 5, but the core purpose is unambiguous.

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

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

The phrase 'when catalog access is available' provides a conditional context for using the joining capability, implying this tool is for scenarios requiring catalog metadata. However, it does not explicitly state when to prefer alternatives like meta_get_insights (which likely omits catalog enrichment) or meta_get_catalog_products (which fetches products directly). Usage guidance is implied rather than explicit.

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

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

No annotations are provided, so the description carries the behavioral disclosure burden. It clearly indicates a read/list operation and qualifies access scope with 'current token', but it does not explicitly state that it is read-only or disclose rate limits, pagination, or permission requirements beyond token access.

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

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

Two concise sentences, with the primary action and scope front-loaded and the second sentence listing useful return fields. There is no filler or redundant 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?

For a zero-parameter list endpoint with no output schema, the description is complete enough: it states what is listed, under what auth scope, and what fields will be returned. No critical missing context is apparent.

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

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

The tool has zero parameters, and the schema covers 100% of them. With no parameters to document, the baseline is 4; the description appropriately includes no parameter information and focuses on the operation.

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

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

The description uses the specific verb 'List' with a clear resource ('all Meta ad accounts') and an explicit scope ('accessible with the current token'). It also names the returned fields, which distinguishes it from sibling account-detail tools like 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?

The description implies when to use this tool: when an agent needs to enumerate the ad accounts available to the current token. However, it does not explicitly mention alternatives or when not to use it, such as when needing a single account's details versus a full list.

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

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

With no annotations, the description carries the burden of behavioral disclosure. It usefully states the operation is read-only, allowlisted, and paginated via cursor. However, it does not mention response shape, potential rate limits, or any edge-specific behaviors, leaving the agent with only a partial understanding of what will happen.

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

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

Two sentences, no filler, and the core behavior is front-loaded. The first sentence packs the essential semantics (list, read-only, allowlisted, fields, filters, cursor pagination) and the second adds the usage context. Every word earns its place.

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

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

For a generic raw-edge tool with 11 parameters, nested filtering objects, no output schema, and no annotations, the description lacks essential context. It does not explain return values, field-selection semantics, filtering syntax, or edge-specific constraints, leaving significant gaps for an agent attempting to invoke it correctly.

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

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

Schema description coverage is only 18%, and most parameters (fields, filtering, since, until, before, after, limit, includeSummary) have no descriptions. The description mentions filters and cursor pagination at a high level but does not clarify syntax, valid formats, or how parameters interact, so it fails to compensate for the low schema coverage.

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

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

The description states a specific action ('List'), a precise resource ('allowlisted read-only Meta Graph edge'), and scope ('caller-selected flat fields, filters, and cursor pagination'). It also differentiates itself from specialized tools by framing itself as the fallback for broad metadata/entity discovery.

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

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

The description gives a clear usage condition: use when a specialized tool does not expose a newly added field. It does not enumerate which siblings to prefer or explicitly say 'do not use' for specialized queries, but the guidance is sufficient for an agent to route appropriately.

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

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

With no annotations, the description carries the burden and does communicate the core behavior: searching by name within an ad account. However, it does not disclose matching semantics beyond what the schema already says, return behavior, or any rate/limit considerations, leaving a modest transparency gap.

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 search scope front-loaded. No filler or redundancy; every clause contributes.

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

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

For a simple search tool with 80% schema coverage, the description plus schema covers the essential call shape. It is incomplete in guiding choice among siblings and in describing expected return output, especially since there is no output schema.

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

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

Schema coverage is 80%, so the baseline is 3. The description's 'by name' maps to nameFilter and enumerates entityType values, but it adds no meaning for adAccountId, limit, or statusFilter beyond the schema descriptions.

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

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

The description names a specific action (Search), specific resources (campaigns, ad sets, or ads), and a scoping attribute (by name within an ad account). This clearly distinguishes it from sibling retrieval tools like meta_get_campaigns, meta_get_adsets, and meta_get_ads.

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

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

It gives an implicit use case ('Useful for finding specific entities') but does not explicitly state when to prefer it over the sibling get_* tools or mention exclusions/alternatives. The guidance is adequate but leaves routing to the agent's 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?

With no annotations provided, the description carries the full burden of behavioral disclosure. It does reveal the operation is read-only and focused on metadata, which is useful, but it omits important behavioral context such as required authentication, pagination behavior, rate limits, or what happens when the 'type' parameter is invalid.

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

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

The description is a single, focused sentence that front-loads the action and resource. The list of targeting metadata types earns its place by clarifying the scope of the search. No redundant or filler wording is present.

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

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

For a tool with five parameters, no output schema, and no annotations, this description is incomplete. It does not mention that 'type' is required, that 'query' is needed for most searches, how 'limit' behaves, or how 'countryCode' and 'locationTypes' narrow results. An agent would likely need to inspect the schema deeply to invoke this tool correctly.

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

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

Schema description coverage is only 20%, so the description must compensate for underdocumented parameters. It does add semantic meaning to the 'type' parameter by listing the categories, but it fails to explain the purpose or behavior of 'query', 'limit', 'countryCode', and 'locationTypes', which are not self-explanatory.

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 ('Search'), a specific resource ('Meta's read-only targeting metadata'), and enumerates the concrete data types it can return (interests, geographies, locales, etc.). This makes the tool's purpose unambiguous and distinguishes it from generic entity search tools like meta_search_entities.

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

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

The description implies the tool should be used when targeting metadata is needed, but it does not explicitly state when to use this tool versus alternatives such as meta_search_entities or meta_get_* tools. There are no exclusions or prerequisite conditions provided, so usage guidance is only implied, not explicit.

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

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

With no annotations provided, the description carries the full burden. It discloses that the tool returns errors and warnings and implies a non-mutating check by saying 'BEFORE executing.' This is adequate, though it does not detail exactly what kinds of validation are performed.

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

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

Two short sentences with no filler. The first sentence states the purpose and result, and the second gives a practical usage hint. Every word earns its place and the key action is front-loaded.

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

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

The description covers the tool's purpose, when to use it, and its return behavior (errors and warnings). The schema fully documents the parameters. It lacks a detailed return schema, but for a validation tool this is a minor gap given the clear description.

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 adds only the phrase 'metric/breakdown combination,' which does not meaningfully extend what the schema already provides; baseline 3 is appropriate.

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

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

The description uses a specific verb ('Validate') with a clear resource ('metric/breakdown combination') and adds the temporal qualifier 'BEFORE executing', making its role distinct from querying tools like meta_get_insights. It clearly states the tool's one specific job.

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

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

The description gives clear usage context: use this tool before executing a query to check whether it will work. It does not explicitly name alternatives or when-not-to-use scenarios, but the 'before executing' framing effectively signals the intended workflow.

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