Metadata MCP Connector

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

Annotations already declare readOnlyHint=true, destructiveHint=false, and openWorldHint=false, so the safety profile is covered. The description adds no behavior beyond that: no mention of pagination defaults, result limits, date-range semantics, or what a stage report 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?

It is a single short sentence with no wasted words, but it is under-specified rather than concise. It offers no front-loaded scope, constraints, or routing information that would earn the brevity.

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 7-parameter, 3-required reporting tool with pagination and stage selection, the description omits how results are scoped and paged, and gives no guidance on the default REACHED tab versus other funnel stages. Annotations and the schema fill part of the gap, but the definition remains thin for a tool an agent must invoke with correct dates and tab.

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%, including pagination, sort syntax, enum meanings, and ISO-8601 date examples, so the schema carries the full parameter burden. The description contributes nothing about parameters; baseline 3 applies.

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

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

The description names the resource ('Account-level funnel performance') and implies a stage breakdown ('across stages'), which matches the reportTab parameter. However it never distinguishes this tool from close siblings such as deep_funnel_stats, account_level_stats, or account_list_performance, so an agent cannot tell from the text which funnel-reporting tool to pick.

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 statement of when to use this tool, when to prefer a sibling, or any prerequisite. The only hint is the phrase 'across stages', which the schema already encodes via the reportTab enum.

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

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

Annotations already declare readOnlyHint=true, destructiveHint=false and openWorldHint=false, so the safety profile is covered. The description adds only that results include a channel breakdown, and says nothing about aggregation behavior or what happens with no params. Adds modest value beyond annotations.

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

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

A single short sentence with the resource front-loaded and no filler. Brevity is good, though it comes at the cost of substance rather than from tight editing of rich 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 stats tool with no required parameters and no output schema, the agent needs to know the default timeframe, the grain of the 'channel breakdown', and how this differs from sibling reporting tools. None of that is present, leaving the definition insufficient to call with confidence.

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

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

Schema coverage is 100%, so the schema fully documents startDate/endDate/timeframe, including the mutual exclusivity rule. The description adds nothing about parameters, which is acceptable at this coverage level. (Note: the schema text mentions MONTH but the enum omits it, an inconsistency the description does not resolve.)

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?

'Account-level statistics and channel breakdown for a timeframe' is largely a restatement of the title, with 'channel breakdown' the only new information. It does not distinguish this tool from the many sibling stats tools (performance_metrics, deep_funnel_stats, demographic_country_stats, account_funnel_reports).

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

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

No guidance on when to use this versus other analytics tools, and no explanation of the default behavior when timeframe/startDate/endDate are all omitted (all params optional). The agent must infer selection from the name alone.

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

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

Annotations already establish readOnlyHint=true and destructiveHint=false, so the safety profile is covered. The description adds nothing beyond that: it doesn't say whether results are paginated (they are, per schema), whether there is a default date window, whether an empty date range returns all-time data, or what the metrics represent.

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

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

It is a single short, front-loaded sentence with no filler, which is structurally fine. However, the brevity comes at the cost of content — the one sentence conveys almost nothing actionable, so it is under-specified rather than efficiently concise.

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

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

With six optional parameters, no output schema, and no annotation detail beyond read-only, the description should explain the returned metrics and default time window. It does neither, leaving the agent to infer behavior entirely 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 100%, and the parameter docs are genuinely good (pagination examples, ISO 8601 format, sort field syntax, channel list format). The description contributes no additional parameter meaning, so the baseline 3 applies.

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

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

The description reads as a restatement of the title: 'Account list information with engagement metrics and statistics' names a resource but no verb/action and no scope. It also fails to distinguish this tool from near-siblings like get_abm_account_lists, account_level_stats, or account_funnel_reports, so an agent cannot tell which one returns what.

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, when not to, or which alternative to prefer. With several account- and performance-oriented siblings in the list, the absence of any routing signal is a real selection hazard.

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

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

Annotations declare destructiveHint=true and openWorldHint=true, but the description goes well beyond them: campaign-level dates overwrite every channel including switched-off ones, draft date writes are partial and can fail entirely, and budget_move_verification returns verified=false with errors even when success=true because the budget group already changed. It also states 'No schedule rollback is attempted', which is exactly the irreversibility an agent needs before calling.

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?

Purpose and the partial-edit rule are front-loaded, but the back half drifts into a dense procedural block on budget-move verification and readback reporting, with mid-sentence line breaks that hurt scanning. Several sentences restate the same irreversibility idea ('No schedule rollback is attempted', 'Do not report dates preserved without that readback'), so it is longer than it needs to be.

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

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

For a single deeply nested campaign_data object with no output schema, the description covers return shape ('updated configuration and per-operation results or errors') and the budget_move_verification field, plus the date-write constraints. It omits prerequisites — permissions, whether the campaign must be a draft or launched for each edit class, and what a per-operation error looks 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 100%, so baseline is 3, but the description adds real semantics on top: a concrete payload example ({"campaignId": 12345, "budgetGroup": "Destination"}) and the rule that only campaignId is required while other fields are additive partial edits. It does not explain channel-block precedence or how google/reddit/linkedin blocks interact, which the schema only partly covers.

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

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

The opening sentence names a specific verb set (add/edit) and resource (audiences, ads, offers, targeting, settings on a Precision Optimization campaign), plus the return value. It scopes itself to Precision Optimization campaigns, which implicitly separates it from add_and_edit_native_campaign_elements, but it never states that contrast explicitly, so an agent must infer the boundary.

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

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

Strong intra-tool guidance: 'CRITICAL: PARTIAL EDITS ONLY', omit name/startDate/endDate/channel blocks unless requested, and a worked budget-group-only payload. What's missing is sibling routing — nothing tells the agent when to prefer add_and_edit_native_campaign_elements, update_reddit_channel_settings, or the remove_* tools instead of this one.

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

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

Annotations already flag destructive=true and openWorld=true, but the description goes far beyond them: it warns that campaign-level startDate/endDate writes hit every channel including switched-off ones, explains draft date-coexistence rules and the no-change-plus-errors fallback, and documents the budget_move_verification contract including that verified=false must halt further moves even when success=true. It also states plainly that no schedule rollback is attempted.

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?

Purpose is front-loaded in one sentence, then a CRITICAL block, then the budget-move workflow — a sensible order for a mutation tool. It is long and the verification paragraph repeats itself slightly ('Do not report dates preserved without that readback; report any mismatch explicitly'), costing a point.

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

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

For a single top-level payload with a deeply nested, platform-specific schema and no output schema, the description covers the risky parts an agent cannot infer: partial-edit discipline, cross-channel date overwrite, draft behavior, and the verification/errors readback. Prerequisites like channel connection and audience resolution are carried by the schema fields.

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

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

Schema coverage is 100% and the nested fields are richly documented, so the baseline is 3; the description still adds value with a concrete payload example (campaign_data={"campaignId": 12345, "budgetGroup": "Destination"}) and the partial-edit contract that governs how the whole object is populated. That is meaning beyond the schema's field-by-field docs.

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 pair (add or edit) and a specific resource (channel containers + campaign-level settings of a Channel First / native campaign), so the agent knows exactly what changes. It does not distinguish itself from the sibling add_and_edit_campaign_elements (the non-native counterpart), which an agent would need to choose between.

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?

Strong when/how guidance: 'PARTIAL EDITS ONLY', 'Supply other fields only for the user's requested changes, never by copying the whole campaign read result', and the explicit omission rule for name/startDate/endDate/channel blocks. It also prescribes the read-before/read-after workflow for a budget-group-only move. It stops short of naming an alternative tool for the non-native case.

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

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

Annotations already declare readOnlyHint=false, destructiveHint=false, and openWorldHint=true, so the mutation surface is known. The description adds the useful behavioral fact that attached extensions are what will actually serve at launch, but says nothing about duplicate handling, whether it appends or replaces existing attachments, or failure modes for invalid extension ids/channel mismatches.

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

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

One sentence, front-loaded with verb and resource, with the downstream effect ('so they actually serve') as the payoff. No filler or restated title text.

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

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

For a simple 3-parameter attach operation with full annotation and schema coverage and no output schema, the description covers enough to call it correctly. The only material gap is append-vs-replace/duplicate semantics, which matters for repeat invocations.

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

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

Schema description coverage is 100% and the schema is unusually explicit — it distinguishes internal library ids from externalId and explains that extensions are a search-channel-only concept. The description adds no parameter-level detail beyond that, so baseline 3 applies.

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

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

Names a specific verb (attach) and resource (existing library extensions such as sitelinks/callouts) scoped to native-structure Google Ads / Microsoft Ads campaigns. The qualifier 'existing library extensions' implicitly separates it from the create_google_*_extension / create_microsoft_*_extension siblings, and 'native-structure campaign' separates it from generic campaign element tools.

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

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

Usage is only implied: 'so they actually serve when the campaign launches' hints at pre-launch setup, but there is no explicit when-to-use, prerequisite ordering (e.g., list_extensions / create_*_extension must run first), or pointer to remove_extensions_from_native_campaign as the inverse operation. The extension_ids schema note partially compensates by pointing at list_extensions.

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

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

Annotations already declare readOnlyHint=false, destructiveHint=false, openWorldHint=false, and the description's 'add' is consistent with an additive, non-destructive mutation. Beyond that it adds nothing: no statement about duplicate handling, whether existing lists are modified in place, or what happens when a keyword already exists. No contradiction, but no extra behavioral context either.

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

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

A single well-formed sentence with the resource and target front-loaded and no filler. It is arguably too terse for a mutation tool, but nothing in it is wasted.

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 four parameters, full schema coverage, and annotations covering the safety profile, the description is just barely sufficient. It omits the Microsoft channel the schema supports, does not say the keywords are appended to every listed ID in one call, and gives no duplicate/return behavior — gaps an agent would need to open the schema to close.

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

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

Schema description coverage is 100%, so the schema already explains channel scoping, the string-vs-{text, match_type} item shapes, the match_type override/default, and where negativeListIds come from. The description's only parameter-adjacent signal is 'one or more', which merely restates minItems, so baseline 3 applies.

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

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

States a specific verb and resource ('Add keywords') and a clear target ('one or more existing ... negative keyword lists'), which distinguishes it from create_negative_keywords_list and remove_keywords_from_negative_list. Minor flaw: it scopes the tool to 'Google Ads' while the schema exposes a MICROSOFT_ADS channel, so the stated scope is narrower than actual behavior.

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?

'existing' implies the lists must already exist and that create_negative_keywords_list is the wrong choice for new lists, and 'one or more' hints at batch use. But there is no explicit when-to-use guidance versus siblings such as add_negative_keyword_lists_to_live_campaigns, and no mention of prerequisites or the need to resolve IDs first (that pointer lives only in the schema).

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

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

Annotations already declare readOnlyHint=false and openWorldHint=true, so the safety class is known. The phrase 'a live edit that syncs through to Google' adds genuinely useful context beyond the annotations: the mutation propagates to the external ad platform and is not contained locally. It doesn't discuss the replace-mode detachment risk, but the schema covers that.

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

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

Two short sentences with zero filler; the scope constraint ('ALREADY LAUNCHED') is front-loaded in the first sentence. The lowercase sentence fragment 'a live edit that syncs through to Google' is stylistically loose but earns its place by conveying the live-sync behavior.

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

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

For a mutation tool with full annotations, a fully documented schema and no output schema, the description supplies purpose, scope and live-propagation behavior. The only gap is what happens on partial success (draft skips, unmatched names), which is handled in schema field text rather than the 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%, including detailed enum semantics for mode and matching behavior for listNames, so the schema carries all parameter meaning. The description adds nothing about any of the five parameters, making baseline 3 the correct score.

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

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

States a specific verb and resource ('Attach existing Google Ads negative keyword lists to campaigns') and scopes it to already-launched campaigns, which cleanly separates it from create_negative_keywords_list and add_keywords_to_negative_lists. It stops short of naming any sibling, so the differentiation is inferred rather than explicit.

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

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

The description establishes the condition 'campaigns that are ALREADY LAUNCHED' and implies draft campaigns are out of scope, giving the agent usable context. It never states when not to use this tool or points at an alternative for drafts or for creating new lists, leaving routing to inference.

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

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

The annotations already declare destructiveHint=true, readOnlyHint=false, and openWorldHint=false, so the safety profile is covered. The description does add one genuinely useful piece of context not in the annotations, namely that this is a soft-delete, but it omits what soft-delete implies operationally (recoverability via unarchive_ad, effect on live delivery, whether dependent entities are touched).

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

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

A single front-loaded sentence with the verb, scope, and the crucial soft-delete qualifier; nothing is wasted or buried.

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 annotations covering safety and a fully described single parameter, the core is covered. However, the description never mentions that archiving is reversible through unarchive_ad or what archiving does to ads in live campaigns, leaving an agent to infer the recovery path.

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

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

Schema coverage is 100% and the ids parameter is fully documented, including bulk usage and the minimum-one constraint. The description only echoes the plural/bulk aspect already stated in the schema, so baseline 3 applies.

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

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

The description names a specific verb (Archive) and resource (ads) and clarifies the semantics as a soft-delete, which distinguishes it from a hard delete. It does not acknowledge the sibling unarchive_ad, 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?

There is no explicit guidance on when to archive versus when to use unarchive_ad, nor on prerequisites such as campaign state or permissions. The intended use is only weakly implied by the verb itself.

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

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

Annotations already mark this as destructive and not read-only. The description adds useful context by stating the consequence of archiving and that the call returns an operation result or error, though it does not discuss reversibility or unarchive_audience.

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

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

Three short sentences, front-loaded with the action and followed immediately by return behavior and the key consequence. There is no redundant or filler language.

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

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

For a low-complexity destructive operation with rich schema descriptions and destructiveHint already present, the description covers the essential consequence and return behavior. It could be stronger by clarifying reversibility or pointing to unarchive_audience, but it is broadly complete.

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

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

Schema description coverage is 100%, and both parameters are documented there, including the name-resolution fallback. The description adds little beyond saying 'by ID,' so the baseline 3 applies.

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

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

States a specific verb and resource: 'Archive a custom audience by ID.' It is clearly distinguishable from most siblings, but it does not explicitly contrast with the obvious reverse operation, unarchive_audience, and 'by ID' is slightly narrower than the schema's name-or-ID resolution.

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

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

The usage context is implied by the stated effect, that archived audiences are no longer available for new targeting. However, there is no explicit guidance on when to choose archival versus alternatives, nor on choosing the name parameter versus custom_audience_id beyond what the schema says.

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

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

Annotations already declare destructiveHint=true, readOnlyHint=false and openWorldHint=true, so the mutating and irreversible-in-spirit nature is known. The description adds one genuinely useful behavioral fact — results are returned per campaign, implying partial success is possible — but stops short of stating whether the operation is atomic, what happens to campaigns already archived, or how failures are reported.

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

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

A single front-loaded sentence with no filler; the trailing clause about per-campaign results is the one piece of non-obvious information and it is kept short. Nothing here could be cut without losing something.

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's 'result per campaign' is the only hint about the response shape and it is thin — an agent still does not know the fields, whether failures appear per item, or whether re-archiving an archived campaign errors. For a destructive batch mutation, that leaves meaningful gaps even with annotations covering safety.

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

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

Single parameter with 100% schema description coverage ('The ids of the campaigns to archive (1 to 50)', uniqueItems, minimum 1), so the schema carries the semantics. The description's 'one or more' is consistent but adds no constraint or format detail beyond it; baseline 3 applies.

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

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

States a specific verb (archive) and resource (campaigns) plus batch scope (one or more). It does not distinguish itself from the closely related sibling unarchive_campaigns or the broader manage_campaign, so an agent must infer the routing 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?

No guidance on when to prefer this over manage_campaign or when to use the inverse unarchive_campaigns, and no preconditions (e.g. campaigns must be paused, must belong to the caller's account) are stated. The batch nature is implied by 'one or more' but nothing else is offered.

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

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

Annotations already establish readOnly=true, destructive=false, openWorld=false, so the safety profile is covered. The description usefully adds that the group ID is resolved internally and that only one page of experiment-level data is returned, which is real behavioral context beyond structured fields. The page-size cap repeats the schema's maximum of 100, so it adds little.

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 zero filler. The identification mechanism and return shape are front-loaded, and the pagination limit is stated last where it belongs.

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 seven parameters but full schema coverage and no output schema, the description adequately conveys the return shape ('one page of experiment performance data with the available pagination metadata'). Minor residual gap: no hint about what happens when a budget group name is ambiguous or not found.

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

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

Schema description coverage is 100%, so every parameter including page, size, sort, date range, and excludeExperimentName is already documented in the schema; the baseline of 3 applies. The description only reinforces that identification is by name and that results are paged, adding no format or semantics beyond the schema.

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

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

States a specific verb (read) and resource (performance statistics for a budget group), plus the key detail that the group is identified by name rather than ID. This distinguishes it from get_budget_group (group definition) and the generic performance_metrics/account_level_stats siblings, though it does not name any of them explicitly.

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

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

Usage is implied by the read-performance framing and the note that the group ID is resolved internally, which tells the agent it doesn't need a lookup step first. There is no explicit when-to-use guidance versus get_budget_group, experiment_performance_stats, or account_level_stats, so the selection decision is left partly to inference.

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

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

Annotations already declare readOnlyHint/non-destructive/closed-world, so the bar is lower, yet the description adds real value: it reads actual platform config, evaluates only ENABLED channels, and surfaces a non-obvious caveat that a later library upload does not repair a creative saved without a Meta video_id. It stops short of describing the exact blocker/report structure.

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?

Front-loads the core purpose in the first sentence and follows with the per-channel evaluation logic and a specific gotcha. The video_id caveat is dense but earns its place; no filler sentences.

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 one-param tool with no output schema, the description adequately covers inputs (wizard campaign), what it evaluates per enabled channel (ads, audience, offer, budget, connection), and outputs (blockers). The precise return shape is only loosely described, a minor gap.

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

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

With a single parameter at 100% schema coverage, the schema already documents campaign_id fully. The description adds only the 'draft campaign' framing, not new syntax or constraints, so the baseline 3 is appropriate.

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

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

States a specific verb and resource ('Check whether a draft campaign is ready to launch, per channel') and clarifies it reads real platform config. An agent can distinguish it from launch_campaign (performs the launch) or get_campaign_by_wizard_id (fetches config) without opening the schema.

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

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

The pre-launch validation context is clear from 'ready to launch' and 'reports blockers,' strongly implying it is called before launch_campaign. However, it never explicitly names launch_campaign as the follow-up action or states exclusions, so the routing is implied rather than spelled out.

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

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

Annotations already flag destructiveHint=true, but the description adds genuinely non-obvious blast-radius information: only the default pointer is cleared and existing channels keep their captured values. It also discloses the response shape (status CLEARED with listId, provider, and name nulled, or an error), which is unavailable elsewhere since there is no output schema.

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

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

Two sentences, zero filler. The action and its scope lead, followed immediately by the non-destructive detail about existing channels and the return contract.

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 input parameters and no output schema, the description carries the full load and does so: it covers effect scope, side-effect limits on existing channels, and the success/error response shape. Nothing an agent needs to invoke this safely is missing.

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

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

The tool takes zero parameters, so there is nothing for the description to disambiguate; the baseline for a parameterless tool is 4. The description correctly implies the target is the single account-level default rather than a caller-specified list.

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 (Clear) plus a precisely scoped resource (the account's default marketing-automation destination list for future campaign-channel creation). This distinguishes it from set_default_ma_list and get_default_ma_list by verb and effect without needing the schema.

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

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

The phrase 'for future campaign-channel creation' implies the context in which the default matters, and 'Existing channels retain their captured values' hints at what this does not affect. However, it never explicitly says when to call this versus set_default_ma_list or get_default_ma_list, nor does it state prerequisites or a when-not condition.

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?

Goes well beyond the annotations: warns that returning the URL does not establish a connection, discloses the LinkedIn-specific extra next_step and why (account/campaign group selection after sign-in), and states the server refuses calls lacking acknowledge_data_access. Annotations only say readOnlyHint=false and openWorldHint=true, so this added detail is genuinely valuable.

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

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

Three tight sentences: what it does, what it returns and the LinkedIn caveat, then the connection-status caveat and the authorization precondition. Front-loaded and every sentence carries actionable information.

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

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

With no output schema, the description still explains the return values (url, state, conditional next_step) and the out-of-band completion flow. The only remaining gap—channel enum aliasing—is fully covered by the schema.

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

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

Schema coverage is 100%, so both parameters are already documented; the description still adds the consequence of omitting acknowledge_data_access ('the server refuses the call') and links it to the credential-grant semantics. It adds a little meaning beyond the schema without fully explaining channel enum aliasing (meta for Facebook/Instagram), which is left to 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 specific verb and resource: 'Create an OAuth authorization URL for the selected advertising channel.' It is clearly distinguishable from sibling mutations like disconnect_channel and from the status-checking get_integrations_status, and it names the return payload (url, state).

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

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

Gives explicit follow-up guidance ('check it afterwards with get_integrations_status') and a hard precondition for external callers (acknowledge_data_access=true). It does not explicitly contrast when to prefer this over disconnect_channel or other channel-connection paths, but the context is otherwise clear.

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

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

Beyond the annotations (readOnlyHint=false, destructiveHint=false, openWorldHint=true), it discloses the key failure mode an agent would otherwise hit: a returned URL is not a live connection. It also states the server refuses the call without acknowledge_data_access and distinguishes external callers from others. Nothing contradicts the declared annotations.

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

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

Four short sentences, front-loaded with the action and followed by the two things that most affect correct use (no connection established; acknowledgement required). The acknowledgement sentence slightly overlaps the schema text but carries the extra external-caller qualifier.

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

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

With only two parameters, no output schema, and annotations covering the safety profile, the description supplies what an agent needs: the return artifact (a redirect URL), the fact it is not a completed connection, and the gating flag. It could go one step further and say the connection is only confirmed later (e.g. via get_integrations_status).

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

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

Schema coverage is 100%, so the baseline would be 3, but the description adds meaning not in the schema: the acknowledgement requirement applies specifically to external callers and gates a credential grant into the user's Metadata account. That clarifies who must pass the flag and why, rather than restating the field.

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

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

Opens with a specific verb and artifact: 'Create an OAuth authorization URL for the selected CRM.' That clearly separates it from the many ad/audience creation siblings and from connect_channel, which it does not name. It stops short of explicit sibling differentiation but the 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 line 'Returning the URL does not establish a connection' positions this as step one of a two-step authorization flow, which tells the agent not to treat the call as completing the connection. The conditional requirement for acknowledge_data_access is spelled out. It never names an alternative (e.g. connect_channel, after which get_integrations_status would be checked), so it lands just below the top score.

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 only declare the write/safety profile (readOnly=false, destructive=false, openWorld=true). The description adds genuinely useful behavior beyond that: the audience is dynamic and 'refreshed automatically as the journey data changes', and it is scoped by a lookback window — key facts for an agent deciding whether a live-syncing audience is appropriate. It omits credit cost, rate limits, and what happens if the segment is not yet READY.

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

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

A single front-loaded sentence with the action and resource first, then a colon introducing the mechanics. Every clause — dynamic, lookback window, auto-refresh — carries information the caller needs; nothing is padding.

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 non-destructive create tool with no output schema and fully documented parameters, the description covers what is produced, how it stays current, and how it is scoped. It stops short of saying what identifier is returned or whether segment readiness is validated at call time.

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

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

Schema description coverage is 100%, so all four parameters are already documented, including the audience_type enum trade-off and the 1–365 lookback range. The description reinforces that lookback defines the evaluation window and the audience is company-derived, but adds no new syntax or format detail. Baseline 3 applies.

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

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

States a specific verb and a precisely qualified resource: a dynamic Insights Retargeting audience built from a saved Insights (Spotlight) segment. That qualification separates it from the many other create_*audience siblings (firmographic, technographic, G2 intent, CSV upload), though no sibling is named explicitly.

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

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

Usage is implied by 'from a saved Insights (Spotlight) segment' — an agent can infer the prerequisite is an existing segment, and the schema reinforces this by requiring a READY segment id from list_segments / create_segment. However, the description names no alternatives (e.g. create_retargeting_audience, create_segment) and states no when-not conditions.

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 only indicate readOnlyHint=false and destructiveHint=false, so the description carries the burden of explaining behavior. It adds valuable context: the dependency on get_intent_topics, AND logic across criteria, examples of include/exclude semantics, and the expected return content (ID, size estimation, creation status). It falls slightly short only because it does not discuss side effects or operational limits, though the annotations already establish this is a write but non-destructive operation.

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

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

The description is not appropriately sized. It is very long and repetitive: the CONTACTS CRITERIA section appears twice with almost identical parameter lists, and several ID labels and examples are duplicated from the input schema. While the most important prerequisite is front-loaded, the redundant sections make the definition harder to scan than it should be.

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 13-parameter tool with no output schema, the description is remarkably complete: it covers prerequisites, when to use, when not to use, alternative tools, full valid value sets, examples, AND logic, and return information. An agent has enough context to decide whether to invoke it and how to fill its parameters 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?

Even though schema description coverage is 100%, the description adds substantial meaning beyond the schema: human-readable labels for industry, job function, and seniority IDs; concrete examples; include/exclude semantics; AND-combination logic; and the instruction to source topic values from get_intent_topics. This goes well beyond what the structured schema alone provides.

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

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

The description clearly identifies the tool as creating Bombora buyer intent audiences on the Metadata platform, and further specifies that it targets B2B audiences by buyer intent topics, firmographics, contact attributes, and geography. This is a specific verb-resource pair that distinguishes it from sibling audience creation tools like create_firmographic_audience or create_g2_intent_*.

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

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

The description provides explicit when-to-use guidance, including a mandatory prerequisite: call get_intent_topics first, and if no topics are returned, do NOT use this tool. It also names the preferred alternative, create_firmographic_audience, making the decision boundary entirely clear.

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

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

Annotations declare destructive/openWorld, and the description adds real context beyond them: the spend-impact confirmation gate, the requires_confirmation non-writing path, and the budget_update_verification contract with an explicit 'stop without retrying when false' instruction. The only thing missing is more on the returned error/validation shape, which it summarizes in one clause.

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?

Front-loads the create/update contract and confirmation gate, and each paragraph carries operational meaning. It is dense but slightly overlong, with some overlap between the description and the already-documented autoPauseConfigurationId schema 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 destructive, open-world mutation with a nested 2-parameter schema, it covers creation, update, cap-only updates, confirmation, verification, and default resolution of the pause rule set, plus a one-line return summary. An agent has everything needed to call it and interpret the result.

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

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

Schema coverage is 100%, so baseline is 3; the description earns extra by explaining defaults and semantics not obvious from the schema, e.g. autoApplyBudget defaults to false and must be explicitly true for platform application, and autoPauseConfigurationId is defaulted on create but retained on update. It partially restates the schema's own field descriptions, which caps it below 5.

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 pair and resource ('Create or update a budget group') plus the fields it carries (channel, metric, allocation, budget settings). It explicitly distinguishes create from update via the presence of 'id', so an agent can route correctly without opening the schema.

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

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

Gives explicit conditions: an id selects an existing group for update, data with only id+monthlyCap is a cap-only update, and confirm_budget_impact=true is required or the call returns without writing. It also points to get_budget_group as the source for valid auto pause rule sets, naming the alternatives an agent needs.

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

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

Annotations already declare that this is a non-read-only, non-destructive, closed-world write. The description adds genuinely new behavior beyond that: the 1x1x1 experiment fan-out (a side effect on campaign structure), how ads attach individually via ads.list versus named groups, and that failures surface as validation errors from the same call. It still leaves the silent-failure traps (channel-locked Lead Gen offers, platform default US location) to the schema rather than the description.

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

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

Four sentences, front-loaded with the core behavior, then channel coverage, then the ad-group caveat, then the return/no-launch boundary. No filler, though the ad-group sentence is dense and packs several constraints into one run-on.

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?

Covers purpose, channel breadth, ad-attachment mechanics, return values ('draft campaign and channel configuration or validation errors'), and the launch boundary — which is enough given a very rich 100%-documented schema and no output schema. The gap is workflow ordering: it never says that ads, offers, and the budget group must exist first, nor points at launch_campaign or check_campaign_launch_readiness.

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

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

Schema coverage is 100%, so baseline is 3, and the description still adds value on top: it explains that ads are attached individually through ads.list, that ads.groups creates named Metadata platform ad groups rather than native platform groups, and that a group needs at least two distinct compatible ads (same ad type on LinkedIn) with a 50-character name cap. That is placement and constraint semantics, not a restatement of field names.

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+resource and a distinctive structural fact: it creates a draft campaign using Precision Optimization (1x1x1) with one experiment per audience/ad/offer combination, and names the six supported channels. It also draws a hard boundary with 'This tool does not launch it.' It stops short of naming the sibling it competes with for alternative structures (create_native_structure_campaign), so an agent must still infer which structure tool to pick.

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 conditional guidance embedded ('ads.groups ... only when the user asks for them') and an implied two-step workflow because the tool explicitly refuses to launch. But no explicit when-to-use vs when-not statement, no mention of launch_campaign by name, and no routing rule against create_native_structure_campaign or add_and_edit_campaign_elements for existing campaigns.

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

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

The annotations already indicate a non-readonly, open-world, non-destructive operation, so the description does not contradict them. However, the description adds almost no behavioral context beyond the platform type: it does not mention side effects, prerequisites, CSV URL requirements, or what happens during resolution of free-text fields.

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

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

The description is a single front-loaded sentence with no filler. It is appropriately concise, though its extreme brevity contributes to gaps in usage and behavioral guidance.

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

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

For a complex audience-creation tool with nine parameters, nested objects, many related siblings, and no output schema, the description is too sparse. It does not explain workflow context, selection criteria among alternatives, or how the CSV upload pathway differs from other LinkedIn native audience creation methods.

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

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

Schema description coverage is 100%, and the parameter descriptions are highly detailed, including mutual exclusivity, enum-like allowed values, and CSV URL format. The tool description itself adds no parameter-level meaning, so the baseline of 3 is appropriate given that the schema carries the burden.

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

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

The description states a specific create action and names the resource as a LinkedIn Native CSV Upload audience, including the platform identifier `customAudienceType=NATIVE_TARGETING_CSV`. It distinguishes this audience type conceptually, but does not explicitly differentiate it from related siblings such as `create_linkedin_native_criteria_audience` or `upload_account_list_csv_audience`.

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 instead of the many sibling audience-creation or CSV-upload tools. It merely states that the tool creates an audience, leaving the agent to infer selection criteria from the name and schema.

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

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

Annotations already declare readOnlyHint=false, destructiveHint=false and openWorldHint=true, so the mutation and open-world profile is covered. The description adds only that criteria must be 'Facebook-supported', hinting at validation of unsupported values, but says nothing about whether creation is idempotent, how duplicate names are handled, or what is returned.

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

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

Two tight sentences with the core action front-loaded and no filler. Nothing is wasted, though the second sentence largely restates the categories already visible in the schema.

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

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

For a creation tool with no output schema, the definition omits anything about what the call returns (e.g., an audience identifier) or that a created audience still needs to be attached to a campaign. With 100% schema coverage and annotations present, the gaps are moderate rather than critical.

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

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

Schema description coverage is 100%, so every parameter, including the enum-constrained countries and industries lists and the estimate_only preview flag, is already documented. The description's mapping of criteria categories to parameter concepts is mildly helpful but adds no syntax or format detail beyond the schema.

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

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

The description uses a specific verb+resource ('Create a Facebook native criteria audience') and enumerates the targeting dimensions it supports (industries, location, job titles, interests, age range). The 'Facebook' qualifier implicitly separates it from the LinkedIn counterpart, though it never names that sibling explicitly.

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

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

There is no when-to-use guidance and no exclusions or alternatives given, despite many sibling audience-creation tools (create_linkedin_native_criteria_audience, create_firmographic_audience, create_audience_from_segment, create_technographic_audience). An agent must infer from the name alone which creator fits a given 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?

Annotations already declare readOnlyHint=false and destructiveHint=false, and the description goes well beyond them: estimate_only=true previews counts (naming expectedNumberOfCompanies, expectedNumberOfContacts, cappedContactCount) without creating anything, criteria combine with AND logic, and the 50-character name limit will hard-fail creation. It does not cover permissions, idempotency, or whether re-creating with the same name collides, which keeps it short of a 5.

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

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

The criteria parameter list is printed essentially three times (inline CONTACTS CRITERIA section, a full 'CONTACTS CRITERIA PARAMETERS' re-listing, then again under PARAMETERS), and the 50-character name warning appears three separate times. The signal is good but is buried in heavy duplication that bloats the definition.

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

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

For a 14-parameter creation tool with no output schema, the description covers creation vs. estimate behavior, required vs. optional fields, ID-vs-free-text distinctions, and combination logic. Only the failure/error surface beyond the name-length rule and the shape of the created-audience response are left unaddressed.

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

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

Schema coverage is 100%, so the baseline is 3, and the description largely duplicates the schema's ID tables rather than adding to them. It adds some value with worked examples (Brazil=[29], Entry+Training=[10,7]), but it also presents revenue ranges as '$1M - $10M' style strings that do not match the schema's required enum values (FROM_1M_TO_10M), which risks misleading rather than clarifying.

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

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

States a specific verb and resource (create B2B company firmographic audiences) plus the scope of criteria (company attributes and contact-level targeting). It explicitly names and contrasts the sibling alternatives create_bombora_audience and create_g2_intent_* tools, so an agent can pick it out of a very crowded sibling set without opening any schema.

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

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

Explicitly declares itself the DEFAULT audience type when no type is specified, and gives conditional routing rules for the alternatives ('only suggest Bombora if get_intent_topics returns topics', 'only suggest G2 if get_integrations_status confirms connection'). A WHEN TO USE block plus common use cases remove nearly all ambiguity about selection.

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

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

Annotations already indicate a non-read-only, non-destructive operation, and the description adds important behavioral context: it requires the G2 integration to be connected, warns not to call if missing, and specifies that buying_stages is mandatory by the platform and must be asked if missing (do not default). It also discloses the daily refresh behavior and return fields, going beyond the annotations.

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

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

The description is well-structured with clear sections (PURPOSE, PREREQUISITE, WHEN TO USE, WHEN NOT TO USE, CONTACTS CRITERIA, PARAMETERS, RETURNS) but it is overly verbose. There is redundancy: the 'CONTACTS CRITERIA PARAMETERS' section repeats the parameter list that already appears in the earlier CONTACTS CRITERIA section and in the schema. This duplication could be trimmed without loss of information.

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

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

Despite having no output schema, the description explicitly lists the return fields (id, audience_id, audience_name, audience_type, status, buying_stages, intent_days, counts). It covers all 12 parameters, explains prerequisites, platform requirements, and usage notes, making it fully complete for an agent to invoke correctly.

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

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

Schema description coverage is 100%, so the baseline is 3, but the description adds significant value by enumerating all valid job function IDs, seniority IDs, country IDs, and state IDs in a readable format, and by explaining usage notes (AND logic, free text vs IDs, include/exclude semantics). This goes beyond the schema's bare descriptions.

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

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

The description states a specific action ('Create a G2 Intent (Dynamic) audience') with the exact platform enum (DYNAMIC_G2_CONTACT) and distinguishes it from the LinkedIn Native and Static sibling tools by name. The purpose is unmistakable and clearly differentiated.

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

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

Explicit 'WHEN TO USE' and 'WHEN NOT TO USE' sections provide exact user phrasings and name the alternative tools (create_g2_intent_linkedin_native_dynamic_audience, create_g2_intent_static_audience). It also states a prerequisite (G2 integration must be connected) and instructs to recommend create_firmographic_audience if not, leaving no ambiguity.

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

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

Annotations already declare readOnlyHint=false, openWorldHint=true and destructiveHint=false, so the write/side-effect profile is covered structurally. The description adds only the platform type identifier; it says nothing about server-side resolution of free-text skills/titles/companies, credit consumption, or failure modes, which is notable for an open-world creation 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?

One sentence with zero filler and the key discriminator front-loaded. It is efficient, though for a nine-parameter creation tool the terseness shades into under-specification rather than pure conciseness.

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

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

For a nine-parameter, open-world creation tool sitting among several near-identical G2/native audience creators, the description does not say how the tool differs from siblings or what the created artifact is (an audience draft vs. a live, actuated audience). With no output schema, the agent gets no help on what comes back.

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

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

Schema description coverage is 100%, so every parameter already carries documentation, including the 'ask the user, do not default' rule on `buying_stages`. The description adds no additional semantics, so baseline 3 applies.

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

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

States a specific verb and resource ('Create a G2 Intent - LinkedIn Native (Dynamic) audience') and pins the platform discriminator with `customAudienceType=DYNAMIC_G2`. That distinguishes it from the non-native G2 intent siblings, though it does not explicitly name `create_g2_intent_dynamic_audience` or `create_g2_intent_static_audience` as the alternatives.

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

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

No statement of when to use this versus the two sibling G2 intent tools or the other native-audience creators. The agent has to infer from the name that 'LinkedIn Native' means a LinkedIn-side dynamic audience rather than a platform-side one.

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

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

Beyond the annotations, the description discloses that the audience is a snapshot at creation time and does not refresh daily, that the G2 integration must already be connected, and that the platform requires `buying_stages` with no defaulting. This gives the agent the non-obvious behavioral context needed for correct invocation.

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 heavily redundant: the CONTACTS CRITERIA section is followed by a nearly identical CONTACTS CRITERIA PARAMETERS section, and there is an internal author note ('Usually after other initial audience parameters to be described next') that is not useful to an AI agent. Although headings help, the duplication and unnecessary prose make it overly long and not appropriately sized.

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

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

For a 12-parameter creation tool with no output schema, the description is very complete: it lists prerequisites, buying-stage requirements, all contact criteria semantics, usage notes, AND logic, and the exact return fields. The agent has enough context to decide when to call it, fill parameters correctly, and interpret the response.

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?

Although the schema already covers all parameters, the description adds meaning by explaining include/exclude semantics, AND logic across criteria, numeric IDs versus free-text job titles, and examples like 'Senior Engineers in California'. It also clarifies that `buying_stages` is platform-required and must be requested from the user, which goes beyond the schema's static description.

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

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

The description opens with 'Create a G2 Intent (Static) audience' and gives the platform enum `customAudienceType=G2_ABM_CONTACT`, a specific verb and resource. It further differentiates from siblings by stating this is the snapshot variant that does not refresh daily and explicitly names `create_g2_intent_dynamic_audience` as the alternative.

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

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

It provides an explicit 'WHEN TO USE' section with exact user phrasings like 'Static G2 audience' and a 'WHEN NOT TO USE' section naming the dynamic sibling tools. It also states the prerequisite that the G2 integration must be connected and instructs the agent to ask for `buying_stages` if missing rather than defaulting.

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

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

Annotations already declare non-read-only, non-destructive, open-world behavior, so the description adds genuine context: it discloses the return shape (result plus identifier) and that validation/platform errors can come back, and it clarifies the operation's scope ends at library creation. It omits account/permission requirements and what happens on duplicate logo creation.

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

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

Three short sentences, front-loaded with the action, with the returning-behavior and scope-boundary statements each earning their place. 'Using the supplied fields' is the one filler phrase that adds nothing.

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

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

No output schema exists, and the description correctly compensates by describing the return value and error outcome. However, for a mutation tool with three fully undocumented parameters and no annotation coverage of auth/rate limits, an agent still lacks enough to build a correct call.

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

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

Schema description coverage is 0%, so the description must carry parameter meaning, yet it only says 'using the supplied fields.' Nothing explains what image_library_id (the sole required param) refers to, nor how domain_name and business_name (maxLength 50/25) relate to the logo or whether they are optional.

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 (Create) plus a specific resource (business logo extension) and its location (the account's Google Ads asset library). It is clearly distinguishable from the many create_google_*_extension siblings and from create_microsoft_business_logo_extension via the platform and asset type named.

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

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

The final sentence explicitly carves out the boundary: creating in the asset library is separate from attaching to a campaign, which routes the agent away from add_extensions_to_native_campaign. It does not name that sibling or state prerequisites/plan requirements, so it falls short of explicit when/when-not guidance.

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

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

Annotations already declare readOnlyHint=false, destructiveHint=false and openWorldHint=true, so safety is covered. The description adds real value on behavior that annotations do not: it discloses the return shape ('extension result and available identifier') and the error classes ('validation/platform error'), plus the non-attaching scope. It stops short of mentioning account permissions or rate limits.

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

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

Three short sentences, front-loaded with the action and target, followed by outcome and scope boundary. No filler and nothing repeated from the title.

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

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

For a one-parameter create tool with no output schema, the description covers what is created, where it lands, what comes back (result plus identifier), what failure looks like, and that attachment is out of scope — everything an agent needs to call it and interpret the response.

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

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

There is only one parameter and schema coverage is 100%, with the schema already documenting the 1-25 character constraint on callout_text. The description adds nothing beyond 'using the supplied fields', so the baseline 3 applies.

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

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

States a specific verb (Create), a specific resource (callout extension), and the precise target (the account's Google Ads asset library), which immediately separates it from create_microsoft_callout_extension and from the other Google extension types in the sibling list.

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

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

The closing sentence 'Attaching the extension to a campaign is a separate operation' gives a clear boundary and implicitly routes the agent to the attach/add-extensions tooling for that follow-up step. It does not name that sibling tool or state prerequisites explicitly, so it falls 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?

The annotations already declare this is a mutation (readOnlyHint=false), open-world, and non-destructive. The description adds valuable behavioral context by stating that it returns the extension result and available identifier, or a validation/platform error, and that attaching is separate. It does not describe permissions or side effects in the asset library, so it is not exhaustive.

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

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

The description is three tight sentences with no filler: it front-loads the creation action, then the return behavior, then the separate-attachment boundary. Every sentence contributes useful information.

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

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

There is no output schema, and the description usefully explains the return value and error behavior. However, for a four-parameter mutation tool with only 25% parameter coverage, the description omits prerequisite details and parameter-level guidance that an agent may need 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 25%, with image_library_ids documented but display_text, destination_url, and alternative_text left undocumented in both schema and description. The phrase 'using the supplied fields' adds no meaning, so the description fails to compensate for the low coverage.

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

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

The description states a specific verb and resource — creating an image extension in the Google Ads asset library — and clearly distinguishes this from attaching the extension to a campaign. The tool name and description are specific enough to separate it from sibling extension-creation tools such as create_google_sitelink_extension or create_microsoft_image_extension.

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

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

It gives a useful usage boundary by noting that attaching the extension to a campaign is a separate operation, which tells the agent this tool only creates the asset. It does not explicitly name alternative tools or when to choose a different extension type, so it falls short of full when/when-not/alternative guidance.

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

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

Annotations already mark this as a non-read-only, open-world, non-destructive mutation. The description adds useful operation-specific context: creation happens in the asset library, the response may include an identifier or a validation/platform error, and attachment is not performed. It omits auth/idempotency details but adds enough beyond annotations.

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

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

Three tight sentences, front-loaded with the action and scope; no redundant repetition. The separate-attachment note earns its place by preventing scope confusion.

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 high-level operation and return/error shape, which is important because there is no output schema. However, for a 13-parameter create tool with almost no schema descriptions, it leaves the agent dependent on field names and types for correct invocation, so it is 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 only 8% (only `url` is documented), and the description contributes nothing beyond 'using the supplied fields'. With 13 parameters and complex fields like `email_lead_form_user_input_types`, it does not 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 verb (Create) and resource (lead form extension) and locates it in the Google Ads asset library, which distinguishes it from the many sibling create_google_*_extension tools. An agent can identify the correct extension type without opening the schema.

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

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

It clarifies the important boundary with campaign attachment ('Attaching the extension to a campaign is a separate operation'), which is the most likely misuse. It does not explicitly name add_extensions_to_native_campaign or explain when to choose a lead form extension over other extension types, so it stops short of full alternative routing.

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

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

Annotations only declare the generic mutation profile (readOnlyHint=false, destructiveHint=false, openWorldHint=true); the description adds real value by describing the outcome surface — returns the extension result plus available identifier, or a validation/platform error. It does not mention permission requirements or platform-side quota behavior, which is the main remaining gap for an open-world write.

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

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

Three short sentences, front-loaded with the action and scope, then the return behavior, then the scoping caveat. 'Using the supplied fields' is slightly redundant filler, but nothing else is wasted.

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 two-parameter create tool with a fully documented schema and no output schema, the description covers action, scope, return shape, error behavior, and the downstream attach step. Only permissions and roughly what the identifier looks like are unaddressed.

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

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

Schema description coverage is 100%, with the nested price_offerings cardinality (3-8) and the price_qualifier enum already documented in the schema. The description only says 'using the supplied fields' and adds no meaning about qualifier semantics or offering constraints, so the baseline 3 applies.

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

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

States a specific verb+resource ('Create a price extension') and pins the scope to the account's Google Ads asset library, which separates it from the many sibling extension creators at Microsoft and from the Google sitelink/callout/image variants. It also preempts the most likely confusion by saying attachment to a campaign is a separate 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?

Gives clear context for when this is the right call (building an asset-library extension) and explicitly carves out the follow-up step ('Attaching the extension to a campaign is a separate operation'), which steers the agent away from expecting campaign-level effect. No named alternative tool is offered, so it falls short of a 5.

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

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

Annotations already establish this as a non-read-only, non-destructive, open-world call; the description adds value beyond them by disclosing the return contract (extension result plus identifier) and the failure modes (validation or platform errors). It does not cover idempotency or what happens when a duplicate promotion already exists, which keeps it from a 5.

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

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

Two compact sentences, front-loaded with the action, with the return/error behavior and the attach caveat placed after. No redundant restatement of the title or name.

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

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

There is no output schema, and the description does a reasonable job summarizing the return, but with 11 parameters and three enums governing conditional requirements, an agent still needs the schema to know which fields pair with which. Adequate rather than complete for a tool of this complexity.

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

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

The description defers entirely to "the supplied fields" and adds no meaning for any of the 11 parameters. Schema coverage is 55% — the conditional fields (details_amount, category_amount, category_percent, details_promo_code) and the date format are documented in the schema, but the required enum fields and conditional pairings are left to the schema alone.

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

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

States a specific verb and resource ("Create a promotion extension in the account's Google Ads asset library") and scopes it correctly. It also explicitly distinguishes itself from the attach operation, which is the natural sibling confusion point alongside add_extensions_to_native_campaign.

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 closing sentence "Attaching the extension to a campaign is a separate operation" gives a real usage boundary and tells the agent this tool alone will not make the extension live. It stops short of naming the alternative tool or stating prerequisites (e.g., account permission, asset library existence), so not quite a 5.

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

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

Annotations already declare readOnly=false, openWorld=true and destructive=false, so safety framing is covered. The description adds real value by scoping the write to the asset library rather than a campaign and by disclosing the outcome envelope (extension result plus identifier, or a validation/platform error). It does not detail rate limits, permissions, or what validation rules apply beyond those in the schema.

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

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

Three tight sentences, front-loaded with the action and scope, followed by the return contract and the boundary against the attach operation. Every sentence carries information an agent needs and there is no filler.

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

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

With no output schema, the description usefully states what is returned and that failures surface as validation or platform errors. Combined with full schema coverage this is nearly complete; only account-context assumptions and any post-creation workflow detail are left implicit.

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

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

All four parameters are required and the schema covers them at 100%, including length constraints, so the schema carries the semantics. The description only says "using the supplied fields" and adds no meaning about how url, link_text or the description lines are used or validated, so the baseline 3 applies.

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

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

The description names a specific verb and resource (create a sitelink extension) plus its scope (the account's Google Ads asset library), which separates it from the Microsoft sitelink sibling and from the other extension-type creators. It also explicitly distinguishes itself from the attach step by noting that "Attaching the extension to a campaign is a separate 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?

It gives clear context for when to use this tool (to populate the asset library) and explicitly points out that attaching to a campaign happens elsewhere, which is a genuine alternative-routing hint. It stops short of naming the sibling tool to use for attaching or stating prerequisites, so it is clear but not a full when/when-not statement.

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

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

Annotations already declare a non-destructive, open-world write, so safety is covered. The description adds outcome behavior beyond that: it returns the created extension result and available identifier, or surfaces a validation/platform error, which tells the agent what to expect on failure.

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 scope, then the critical boundary condition. The only mildly redundant phrase is 'using the supplied fields', but it does no harm.

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 two-parameter creation tool with no output schema, the description covers what is created, where it lives, what comes back, and the fact that attachment is out of scope — nothing an agent needs to call it correctly is missing.

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

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

Schema description coverage is 100% (header 1-25 chars, 3-10 values of 1-25 chars each), so the schema fully documents both required params. 'Using the supplied fields' adds nothing beyond it; baseline 3.

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

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

States a specific verb and resource ('Create a structured snippet extension') plus scope ('in the account's Google Ads asset library'), which separates it from the campaign-attachment sibling add_extensions_to_native_campaign and from other extension types.

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

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

Explicitly routes the agent away from attaching the extension: 'Attaching the extension to a campaign is a separate operation.' That is a genuine when-not clause naming the follow-on step, though it doesn't name the specific sibling tool to use for attaching.

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

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

Annotations already declare readOnlyHint=false, destructiveHint=false, and openWorldHint=false, so the write-but-non-destructive profile is covered. The description adds the useful 'positive keywords in the library' scoping, but says nothing about duplicate handling (whether existing keywords error, dedupe, or are silently skipped) or what the call returns.

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

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

One front-loaded sentence with zero waste; the scope qualifier ('positive', 'library') arrives before any would-be 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 single-parameter creation tool with full schema coverage, annotations, and no output schema, this is nearly sufficient. The one meaningful gap is duplicate/conflict behavior when creating keywords that already exist in the library.

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

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

Schema coverage is 100% and the single `keywords` array is fully documented with item semantics, example values, and the empty-string edge case. The description only adds 'one or more', which merely restates minItems: 1, so baseline 3 applies.

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

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

States a specific verb and resource ('Create one or more positive keywords') and scopes it to the 'Metadata platform library', implicitly separating it from campaign-level and negative-keyword siblings. It doesn't name those siblings explicitly, so the differentiation is inferential rather than stated.

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

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

Usage is only implied: the agent can infer this creates library-level keywords rather than attaching them to a campaign, but there is no explicit guidance on when to use this instead of add_keywords_to_negative_lists or add_and_edit_campaign_elements, and no prerequisites mentioned.

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

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

Annotations already declare readOnlyHint=false, destructiveHint=false, and openWorldHint=true, so the safety profile is known. The description adds no behavioral context beyond that: it does not mention that this is a mutation that creates a persistent audience, that source/trigger pairs can silently produce a never-populating audience, or that WEBSITE switches the tool into a different URL-rule shape.

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 tight sentence with the resource and audience definition front-loaded. There is no filler text to trim.

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

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

For a 7-parameter, 4-required creation tool with a dual WEBSITE vs non-WEBSITE shape and no output schema, one sentence is far too thin. The description should at minimum flag the WEBSITE branch, the required URN lookup for other source types, and the fact that a new persistent audience is created — none of which it does.

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

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

With 100% schema description coverage across all 7 parameters, the schema already documents name, the WEBSITE-only fields, source_platform, engagement_trigger, lookback_window_days, and engagement_source_urns with helpful detail. The description adds no parameter-level meaning beyond what the schema provides, so the baseline 3 applies.

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

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

The description gives a specific verb and resource ('Create a LinkedIn Engagement Retargeting audience') and clarifies the underlying population (people who engaged with ads, page, or website). It is clear about what is produced, but it never distinguishes this tool from close siblings such as create_retargeting_audience or create_linkedin_native_criteria_audience, leaving the agent to infer which retargeting constructor applies.

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 when-to-use, when-not-to-use, or alternative guidance. The description also omits the prerequisite discovery steps that the schema implies (consulting get_linkedin_engagement_source_types and search_linkedin_engagement_sources before calling), so an agent cannot tell from the description how this fits into the workflow.

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

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

Annotations already declare openWorldHint=true, readOnlyHint=false and destructiveHint=false, so the write/external-call profile is covered. The description adds the constraint that criteria must be LinkedIn-supported, but says nothing about persistence, what is returned on success (audience ID vs. estimate count), or failure modes when criteria are unsupported.

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

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

Two short sentences, front-loaded with the action and resource. The second sentence is partly redundant with the first ('LinkedIn-supported targeting criteria' then a list of those criteria), which keeps it just short of a 5.

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

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

For an 8-parameter mutation tool with no output schema, the description omits what the agent gets back (new audience identity, estimated size) and whether the created audience is immediately usable for targeting. The rich schema compensates for parameters, but return-value behavior is left unexplained.

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

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

Schema description coverage is 100%, with each parameter carrying enums, examples and formats. The description's list of criteria categories mirrors the schema fields and adds no syntax, format or validation detail beyond it, so baseline 3 applies.

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

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

Clear verb+resource: 'Create a LinkedIn native criteria audience using LinkedIn-supported targeting criteria.' The word 'criteria' implicitly distinguishes it from create_csv_upload_linkedin_native_audience and create_g2_intent_linkedin_native_dynamic_audience, but that contrast is never made explicit.

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

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

The description says what an audience can be built from but never states when to choose this tool over the many sibling audience-creation tools (CSV upload, Facebook native criteria, LinkedIn engagement retargeting, G2 intent). The important estimate_only preview workflow is documented only in the schema, not surfaced as usage guidance.

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

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

Annotations already declare readOnlyHint=false, destructiveHint=false and openWorldHint=true, so the safety profile is covered structurally. The description adds the platform-side audience type mapping, which is useful for interpreting errors, but says nothing about whether creation is reversible, what happens on duplicate names, or provider auth requirements — meaningful gaps for an open-world write.

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

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

A single front-loaded sentence with no filler; the created resource and its origin both land 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?

With full schema coverage, no output schema and explicit annotations, the definition is nearly self-sufficient. The only missing piece is outcome information (what is returned or what to do after creation), which is minor for a create operation at this schema richness.

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

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

Schema description coverage is 100% and every parameter, including the STATIC/DYNAMIC enum semantics and the no-'/' name constraint, is already documented in the schema. The description's mention of STATIC/DYNAMIC simply restates the variant enum, adding no new parameter-level meaning.

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

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

The description gives a specific verb and resource ('Create a Marketing-Automation-contacts custom audience') and even names the underlying platform types (MA_CONTACTS_STATIC/MA_CONTACTS_DYNAMIC), which lets an agent distinguish it from siblings such as create_salesforce_contacts_audience or create_audience_from_segment. It stops short of explicitly naming those alternatives, so it is clear but not fully differentiated.

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

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

The phrase 'from a provider library list' implies the prerequisite (a library list id sourced elsewhere), but the description never states when to choose this tool over the other audience-creation tools or any when-not conditions. Usage is inferable rather than stated.

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

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

Annotations already declare a non-read-only, non-destructive, open-world write; the description adds real value by disclosing the return ('extension result and available identifier') and failure mode ('validation/platform error'). It does not mention that creation mutates the shared asset library or any account-access requirements.

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

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

Three short sentences, front-loaded with the action, then the outcome, then the scoping caveat. No filler.

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

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

No output schema exists, and the description usefully covers return values and errors, so that gap is closed. However, with three parameters at 0% schema coverage and no explanation of the required image_library_id, an agent still lacks enough to populate the call confidently.

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 carries the full burden — but 'using the supplied fields' adds nothing. Nothing explains that image_library_id is a required reference to a previously uploaded image asset or what domain_name/business_name constrain, despite the 25/50 character limits.

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

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

States a specific verb and resource ('Create a business logo extension') scoped to the Microsoft Ads asset library. This clearly separates it from the Google counterpart (create_google_business_logo_extension) and from the various Microsoft callout/image/price/sitelink siblings.

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

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

Adds a valuable routing note: 'Attaching the extension to a campaign is a separate operation,' which steers the agent away from expecting campaign association here. It doesn't state prerequisites such as needing an existing image library asset, and gives no explicit when-not guidance.

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

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

Annotations already declare readOnlyHint=false, openWorldHint=true and destructiveHint=false, so the write/non-destructive profile is known. The description adds real value beyond that: it says the call returns the extension result and identifier, and that failures surface as validation or platform errors. It does not cover auth/account requirements or duplicate-handling.

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

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

Two sentences with zero filler; the creation scope leads and the attach-separation caveat follows. Nothing repeated from the title or schema.

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

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

For a single-required-parameter create tool with full annotation coverage and no output schema, the description covers purpose, return payload, error behavior, and the follow-up attach operation. An agent has everything needed to call it and interpret the result.

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

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

Schema description coverage is 100% and the single callout_text parameter already carries its 1-25 character constraint in the schema. "Using the supplied fields" adds no meaning beyond that, so the baseline 3 for a fully documented schema applies.

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

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

States a specific verb and resource ("Create a callout extension in the account's Microsoft Ads asset library"), which separates it from the Google callout sibling and from the sitelink/price/promotion Microsoft extension creators. It never names an alternative tool outright, but the note that attaching is a separate operation implicitly draws the boundary against add_extensions_to_native_campaign.

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?

"Using the supplied fields" plus "Attaching the extension to a campaign is a separate operation" gives the agent clear context for when this tool is the right call and warns that creation alone does not deploy the asset. There is no explicit when-not guidance or named alternative, which keeps it below a 5.

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

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

Annotations already declare readOnlyHint=false, destructiveHint=false and openWorldHint=true, so the safety profile is known. The description adds genuine context beyond that — it discloses the return payload (extension result plus identifier) and that failures surface as validation/platform errors — but says nothing about permissions, duplicate handling, or whether the created asset is reusable across campaigns.

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

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

Three short sentences, front-loaded with the action and immediately followed by the return behavior and the scope boundary. No filler, though it is slightly terse for the amount of undefined parameter surface it covers.

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?

Knowledge that there is no output schema makes the return-value sentence valuable, and the scope boundary is a useful addition. However, with four parameters at 25% schema coverage and no annotations explaining mutation semantics, the description leaves field-level meaning and prerequisite context under-specified.

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 only 25% — only image_library_ids carries a description. The description's "using the supplied fields" adds no meaning for display_text, destination_url, or alternative_text, so an agent gets no guidance on what alternative_text is for versus display_text, or what URL constraints apply to destination_url.

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

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

States a specific verb and resource: creating an image extension in the account's Microsoft Ads asset library. It also distinguishes itself from the attach-to-campaign flow without naming the sibling explicitly, which is enough for an agent to tell it apart from create_google_image_extension or upload_image_creative.

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?

"Attaching the extension to a campaign is a separate operation" implies this tool only creates the library asset, and presumes image_library_ids already exist. There is no explicit statement of when to prefer this over create_google_image_extension or upload_image_creative, so usage is only implied.

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

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

Annotations already declare a non-read-only, non-destructive, open-world write. The description adds value beyond them by disclosing outcome semantics ('Returns the extension result and available identifier, or a validation/platform error') and that the asset is not attached to any campaign by this call — useful, non-obvious context for a mutation tool.

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

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

Two tight sentences: the action and scope come first, then return behavior and the attach caveat. No filler and nothing restated from the annotations.

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 write tool with no output schema, the description covers what is created, what comes back, and what is not done (attachment). Remaining gaps are minor — which account identifier the call implicitly targets and any per-account extension limits are unstated, but the schema carries the field-level constraints.

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

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

Schema coverage is 100% — nested offering fields, the 3-8 item bounds, length limits, and the price_qualifier enum are all in the schema. The description adds only 'using the supplied fields', which conveys nothing beyond the schema, so the baseline 3 applies.

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

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

States a specific verb and resource ('Create a price extension in the account's Microsoft Ads asset library'), which cleanly separates it from the many sibling extension-creation tools for Microsoft, Google, and other asset types. It also disambiguates library creation from the separate attach step.

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

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

Explicitly scopes the tool to asset-library creation and states that 'Attaching the extension to a campaign is a separate operation', which prevents the common misuse case. It stops short of naming the sibling that performs the attach, so the agent must infer the follow-up tool.

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

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

The annotations already establish that this is a non-read-only, open-world, non-destructive operation. The description adds useful behavioral context beyond those annotations by stating that it returns the extension result and identifier, or a validation/platform error, and that campaign attachment is not part of this call.

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

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

The description is three tight sentences with the core operation front-loaded, followed by return behavior and the important attachment scope. There is little waste and the key routing information is 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 relatively complex create tool with no output schema, the description does well by explaining the return and separation from attachment. However, it does not surface required-field or conditional-parameter expectations, leaving an agent to rely on a partially documented input schema.

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

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

The description only says 'using the supplied fields' and does not explain the 11 parameters or their conditional relationships. With only 55% schema description coverage, it does not compensate for undocumented required fields such as occasion, item, category_type, and details_type, though the schema's enums and some optional-field descriptions carry partial meaning.

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

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

The description uses a specific verb and resource: 'Create a promotion extension' in the Microsoft Ads asset library. It distinguishes the operation from Google promotion extensions by naming Microsoft Ads, and distinguishes asset creation from campaign attachment by explicitly stating that attaching is a separate 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?

It clearly indicates that this tool creates an asset and that attaching the extension to a campaign is handled separately, which prevents a common misuse. It does not enumerate when to choose this over the other Microsoft extension creation siblings, but the resource name makes the intended use clear.

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

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

Annotations already declare the write/open-world/non-destructive profile, and the description adds useful behavior: the return shape ('extension result and available identifier') and the failure modes ('validation/platform error'). The note that attachment is independent clarifies side-effect scope. It does not mention duplicate handling or permission/account prerequisites.

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: capability first, then return/error behavior and the scoping caveat. No redundant restatement of the title or parameters; every clause carries information.

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

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

With no output schema, the description usefully summarizes the return value and error behavior, and the scope note prevents confusion with attachment. For a simple four-required-field creation tool this is nearly complete; only account/permission preconditions are unaddressed.

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

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

Schema description coverage is 100% and all four fields carry limits (1-25 chars link text, 1-35 for descriptions), so the schema does the heavy lifting. The description only says 'using the supplied fields' without naming or explaining any of them, so baseline 3 applies.

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

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

States a specific verb and resource — 'Create a sitelink extension in the account's Microsoft Ads asset library' — and the platform qualifier distinguishes it from create_google_sitelink_extension. The closing sentence separates it from the attach operation (add_extensions_to_native_campaign), so siblings are disambiguated.

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 establishes clear context (standalone asset-library creation, not campaign attachment) and explicitly warns that attaching is a separate operation, which prevents a common misuse. It stops short of naming the attach sibling or stating when to prefer it over creating a sitelink inline elsewhere.

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

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

Annotations already declare readOnlyHint=false, destructiveHint=false and openWorldHint=true; the description adds value beyond them by stating the return contract (extension result plus identifier, or a validation/platform error). It could go further on idempotency or duplicate handling, so not a 5.

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

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

Two sentences, front-loaded with the action and scope, with the second sentence carrying a non-obvious behavioral boundary. No filler.

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

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

With no output schema, the description compensates by describing the return value and error modes, and it clarifies the attach-vs-create boundary. Complete enough to invoke correctly, though it omits any note on duplicates or account-level constraints.

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

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

Schema coverage is 100% and both parameters carry min/max constraints and item counts in the schema, so the schema does the heavy lifting. The description adds nothing beyond 'using the supplied fields', matching the baseline 3 for fully documented params.

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

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

States a specific verb and resource ('Create a structured snippet extension') plus the exact location ('Microsoft Ads asset library'), which cleanly disambiguates it from the Google equivalent (create_google_structured_snippet_extension) and from other Microsoft extension creators such as sitelink or callout.

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 closing sentence, 'Attaching the extension to a campaign is a separate operation,' gives clear scoping guidance about what this tool does and does not do. It stops short of naming the sibling tool to use for attachment or of explicitly contrasting with the Google variant, so it stops at 4.

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

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

Annotations already declare the tool is not read-only, not destructive, and not open-world. The description adds useful context beyond that: it creates a draft (not a launched campaign) and returns the draft campaign and channel configuration or validation errors, which helps set expectations for side effects and responses.

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 four short sentences, front-loaded with the core action and resource. Every sentence contributes value: structure name, container grouping, return behavior, and the draft-only caveat.

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

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

Given the complexity and the very rich input schema, the description covers what the tool does and what it returns. It could mention prerequisites such as needing existing ads/offers or connected channels, but those details are already in the schema descriptions.

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

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

The schema has 100% description coverage and is extremely detailed, so the baseline is 3. The description only summarizes that audiences, ads, and offers are grouped within channel-specific containers, adding little beyond what the nested schema already explains.

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 (Create), resource (draft campaign), and structure type (Channel First / Native Structure N×N×N). It distinguishes this tool from the generic create_campaign and from launch_campaign by explicitly noting 'This tool does not launch it.'

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

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

Usage is implied: use this tool to create a draft campaign with native structure, as opposed to launching one. However, it does not explicitly state when to choose this over sibling tools like create_campaign or add_and_edit_native_campaign_elements, nor does it name the alternative for launching beyond the exclusion.

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

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

Annotations already declare readOnlyHint=false, destructiveHint=false and openWorldHint=false, so the safety profile is covered. The description adds only 'in the Metadata platform with Google Ads integration', which is thin for a mutation and arguably narrows scope in a way the channel parameter contradicts; it says nothing about validation limits on keywords, whether creation is idempotent, or what is returned.

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 with no filler, front-loading the verb and resource. It is not padded, though its brevity leaves no room for the routing or lifecycle information an agent needs.

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 mutation tool with no output schema, the description should say what comes back (e.g. the new list's identifier) and what state the result is in. Neither the return value nor the standalone-vs-attached lifecycle is addressed, leaving the agent to guess the next step after creation.

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

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

Schema description coverage is 100% and the channel enum itself explains the per-channel isolation and default, so the heavy lifting is done structurally. The description adds no parameter meaning and its 'Google Ads integration' phrasing points away from the supported MICROSOFT_ADS option, so baseline 3 rather than higher.

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

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

States a specific verb plus resource ('Create a new negative keywords list') and names the platform, so the basic action is unambiguous. It does not distinguish itself from close siblings such as duplicate_negative_keywords_list or add_negative_keyword_lists_to_live_campaigns, which an agent must infer.

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

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

No guidance on when to use this versus duplicating, listing, or attaching an existing list to campaigns. The critical workflow fact — that a newly created list is standalone and must be pushed live via add_negative_keyword_lists_to_live_campaigns — is absent.

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

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

Annotations already cover the mutation profile (readOnlyHint=false, destructiveHint=false, openWorldHint=true), so the bar is lower. The description still adds real value by disclosing the return surface ('Returns the group or validation/platform errors') and the ordering invariant that the first include block is location criteria with isModifiable=false — something an agent would otherwise get wrong. It omits any mention of permissions or rate limits, so it is good but not exhaustive.

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

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

Three short sentences, front-loaded with the core action and followed by return behavior and the structural caveat. The final sentence about isModifiable is slightly orphaned without saying why it matters, but nothing is wasted.

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 write tool with a deeply nested 2-parameter schema at full description coverage and no output schema, the description covers action, return/error shape, and the key structural constraint. The main gap is not routing the agent to search_reddit_criteria for valid criterion values — that dependency lives only in the schema text.

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

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

Schema coverage is 100% and the nested targeting object documents include/exclude, criteria, and audiences in detail, so the baseline is 3. The description's only addition is the first-include-block/location/isModifiable rule, which partly duplicates the targeting schema description — real but marginal added meaning.

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

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

States a specific verb and resource (create a Reddit target group) plus the kinds of criteria it accepts, which distinguishes it from generic siblings like create_target_group or create_retargeting_audience. It never explicitly names the Reddit-specific alternative or explains when the generic sibling applies, so sibling differentiation is only implied by the 'Reddit' qualifier.

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 tells the agent what content belongs in a group (location, communities, interests, keywords, optional audience references) and gives one structural rule about the first include block, which implies how to build the payload. It gives no explicit when-to-use/when-not guidance versus create_target_group, update_target_group, or estimate_target_group, and does not mention the search_reddit_criteria prerequisite that the schema carries.

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

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

Annotations already cover safety (readOnly=false, destructive=false, openWorld=true), so no credit is due for restating that this is a creation. The description adds nothing operational: no mention of duplicate handling if the audience already exists, whether the channel must be connected first, or whether the new audience is auto-attached to any campaign.

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

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

A single, front-loaded sentence with no filler. It is efficient but its brevity comes at the cost of specificity rather than through disciplined editing.

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 creation tool with a rich nested schema and no output schema, the schema carries most of the weight, but the description omits the source-tool dependency and any post-creation behavior. Adequate to identify the call, thin on how to use it correctly.

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

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

Schema description coverage is 100% and the nested audience_data object fields (id, name, type, subtype, channel, externalAccountId) are fully documented in-schema. The description contributes only the loose phrase 'native channel audiences' and nothing on required field semantics, so baseline 3 applies.

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

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

States a specific verb and resource ('Create a new retargeting audience') and adds a modest qualifier ('from native channel audiences') that hints at the input source. It does not distinguish itself from the many sibling audience-creation tools (create_linkedin_engagement_retargeting_audience, create_audience_from_segment, create_g2_intent_dynamic_audience, etc.), so the agent still has to infer which creator applies.

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, and no alternative named among the ~20 sibling create/upload audience tools. The crucial prerequisite — that audience_data should come from get_retargeting_audiences — appears only in the schema, not the description.

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

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

Annotations already declare readOnlyHint=false, destructiveHint=false, and openWorldHint=true, so the safety profile is clear. The description adds useful context by naming the platform customAudienceType values and source entity, but it does not disclose creation side effects, idempotency, permissions, or return 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 efficient sentence with the resource and source stated up front. It contains no filler and every clause adds relevant context.

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 three-parameter, fully documented create tool, the description gives enough context to understand what is being created and from what source. It lacks explicit usage prerequisites and return-value detail, but annotations and schema cover most operational needs.

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

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

Schema description coverage is 100%, so all three parameters are already documented in the schema. The description adds only the customAudienceType mapping context and does not provide syntax or selection guidance 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 uses a specific verb and resource: 'Create a Salesforce-contacts custom audience.' It also states the platform customAudienceType values and that the audience comes from a Salesforce mixed-criteria, which clearly distinguishes it from sibling audience-creation tools.

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

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

The description does not explicitly state when to use this tool versus alternatives or what prerequisites are required. It implies the source is a Salesforce mixed-criteria, but does not mention listing criteria first or how to choose between the static and dynamic variants.

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 annotations already stating readOnlyHint=false, destructiveHint=false, and openWorldHint=false, the description usefully adds that the tool returns segment ID, name, status, and available account count, and that invalid criteria produce validation errors. It also discloses the three-level nested group limit, though it does not discuss permissions or failure modes beyond validation.

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

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

The description is three tight sentences with the core action front-loaded, followed by return behavior and validation constraints. Every sentence adds useful information without redundancy.

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

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

For a tool with a complex nested schema and no output schema, the description does well by stating the return fields and validation behavior and by noting the nesting depth limit. It is not fully complete because it leaves criteria grammar and field/operator semantics largely to the schema, but it covers the main agent needs.

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

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

Schema coverage is 67%, and the description adds meaningful context about typed criteria and a maximum of three nested criteria group levels. However, it does not explain the AND/OR operator semantics or the distinction between field/property/entity criteria, and it does not mention the optional lookback_window parameter.

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

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

The description uses a specific verb and resource: "Create a saved Insights segment from typed criteria over account-journey records." It clearly identifies the object and the data domain, but it does not explicitly distinguish this tool from nearby siblings such as create_audience_from_segment, list_segments, or get_segment_criteria.

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

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

The description implies that this is the creation path for saved segments, but it gives no explicit when-to-use guidance, prerequisites, or comparison with alternatives like create_audience_from_segment or list_segments. An agent must infer the routing decision from context 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?

Annotations already declare mutation (readOnlyHint=false) with destructiveHint=false and a closed-world scope, so the safety bar is lower. The description adds real value beyond that: it warns that criteria and audience references are validated server-side against the account and channel, and states the failure mode (validation/platform errors) alongside the success return, which tells the agent to expect rejection rather than silent coercion.

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

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

Three sentences, no filler: identity of the operation first, the validation constraint second, the return/error contract last. Every sentence carries information an agent would not get from the structured fields alone.

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 nested three-parameter creation tool with no output schema, the description covers the essentials: what is created, what gets validated, and what comes back. It doesn't cover permission/connection requirements or suggest estimating audience size before committing, and the "include rules" phrasing slightly overstates an optional field.

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

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

Schema description coverage is 100% and the nested targeting/exclude structures are documented in-schema, so the baseline of 3 applies. The description only restates the parameter surface (name, include, exclusions) without adding format, cardinality, or channel-specific criterion-type guidance. One nuance: it frames include rules as part of the create payload while `targeting` is in fact optional — a mild imprecision the schema corrects.

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

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

States a specific verb and resource ("Create a LinkedIn target group") and enumerates the composition (name, include rules, optional exclusions), which cleanly separates it from update_target_group, retrieve_target_group_by_id, list_target_groups and create_reddit_target_group. It stops short of naming any sibling explicitly, so differentiation is inferable rather than stated.

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

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

No explicit when-to-use/when-not guidance and no pointer to adjacent tools an agent would need before calling it (search_target_group_criteria, estimate_target_group, list_target_groups for duplicate-name checks). The line about criteria and audience references being "validated against the account and channel" implies a prerequisite ordering but doesn't state it as a workflow.

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