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

Annotations declare readOnlyHint=false and openWorldHint=true, so the mutation nature is covered by structured data. Beyond that, the description repeats the 25-char limit already in the schema and says nothing about where extensions are applied, whether the call replaces or appends existing callouts, or permission requirements — a meaningful gap for a write 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 short, front-loaded sentence with zero padding. It is appropriately sized, though the duplicated constraint from the schema means the sentence earns slightly less than it could.

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

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

A mutation tool with no output schema and an ambiguous placement scope (campaign vs ad group level), yet the description does not say where these callouts land or what a successful call returns. The agent is left guessing at required preconditions.

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 a single well-documented parameter (maxLength 25, 1-1000 items), so the baseline is 3. The description only echoes the schema's length constraint and adds no new semantics.

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

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

States a specific verb + resource ('Создать уточнения (callouts)') and adds a concrete constraint (each text up to 25 characters). It is distinguishable from list_ad_extensions and delete_ad_extensions by the create verb, but it never explicitly references those siblings or what entity (campaign/ad group) the callouts attach to.

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 guidance, no prerequisites, no mention of what must already exist (a campaign or ad group) or how it relates to list_ad_extensions/delete_ad_extensions. The agent must infer the whole invocation context.

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

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

Annotations already declare readOnlyHint=false and openWorldHint=true, so the mutation and open-world nature is covered. The description adds real value by explaining that 100 leaves the bid unchanged and 0 disables impressions for that slice, but it says nothing about permissions or whether adding an adjustment merges with or replaces existing ones — critical given a set_bid_adjustments sibling exists.

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

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

Two sentences, zero waste, with the operation and its scope front-loaded before the coefficient semantics. Nothing could be removed without losing information.

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

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

For a mutation tool whose annotations cover the safety profile and whose schema is fully documented, the description is nearly sufficient. The notable gap is that it does not resolve add-versus-set semantics against a very similar sibling, which is exactly the ambiguity an agent needs resolved here.

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 the same '100 — ставка без изменений' note for bid_modifier, so the description's coefficient explanation is largely redundant with structured data. Baseline 3 is appropriate when the schema fully documents all parameters.

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

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

States a specific verb and resource ('Создать корректировки ставок') and names the two scopes it applies to (кампании или группы). It is clear on its own, but it never distinguishes itself from the sibling set_bid_adjustments, which is the most likely confusion for an agent choosing between them.

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

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

There is no explicit when-to-use guidance and no mention of the alternatives. With get_bid_adjustments, set_bid_adjustments and delete_bid_adjustments all present as siblings, the agent gets no hint about when to add versus when to set or overwrite existing adjustments.

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

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

Annotations declare readOnlyHint=false and openWorldHint=true, so the write and external-system traits are covered structurally. The description adds nothing beyond that: no mention of auth requirements, whether phrases are appended vs replacing, duplicate handling, limits on count, or that new phrases start in a pending moderation state.

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

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

A single short sentence with the action front-loaded and zero filler. Nothing to trim.

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

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

For a mutation tool with no output schema and many keyword siblings, the description omits prerequisites, append semantics, duplicate behavior, and moderation state. The structured fields cover safety and params, but the behavioral context an agent needs to call this correctly versus update_keywords is absent.

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

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

Schema coverage is 100%, so both parameters are already documented, including the hyphen-minus-word convention in the schema itself. The description adds no syntax, format, or constraint detail beyond the schema, so baseline 3 is correct.

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

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

States a specific verb (добавить) and resource (ключевые фразы в группу объявлений), which is clearer than a tautology. However, it doesn't distinguish itself from siblings like update_keywords, manage_keywords, or set_keyword_bids, so the agent can't tell when this specific add-path applies versus those.

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 context, no prerequisites, and no mention of alternatives such as update_keywords for existing phrases. The agent gets an implied action but no routing guidance among the many keyword siblings.

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

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

Annotations already declare readOnlyHint=false and openWorldHint=true, so the write nature is covered. The description confirms it is a creation operation built from Metrica goals/segments but adds no side-effect, permission, or idempotency context beyond what the annotations and schema already convey.

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

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

A single front-loaded sentence with the verb first and zero filler. Efficient, though arguably too terse for a tool whose rules array has nested semantics.

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, fully documented parameters, and annotations covering the mutation profile, the description is minimally adequate. It could have explained the rules structure or creation behavior, but the schema carries most of the load.

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

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

Schema description coverage is 100%, so the baseline is 3. The phrase 'из целей Метрики, сегментов или интересов' loosely maps to the type enum (RETARGETING/AUDIENCE) but introduces 'интересы', which has no corresponding enum value, adding slight ambiguity rather than 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 ('условие ретаргетинга'), and names the source data (цели Метрики, сегменты, интересы). Clear enough to distinguish it from the list/update/delete siblings by name, but it never explicitly contrasts itself with update_retargeting_lists or list_retargeting_lists.

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 guidance and no mention of alternatives, despite being one member of a CRUD family (list_/update_/delete_retargeting_lists). The agent must infer that this is the creation path from the tool 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 declare readOnlyHint=false and openWorldHint=true, so the agent knows this is a mutating, externally-visible operation. The description adds nothing beyond that: no note on whether the vCard becomes immediately active, whether existing vCards in the campaign are affected, or any limit on how many vCards a campaign may have.

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 or redundancy. It is efficient, though its brevity is close to under-specification rather than exemplary 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?

This is a high-complexity mutation with 18 parameters, 8 required, no output schema, and only two structural annotations. The description leaves out the campaign-prerequisite relationship, the effect of creation on existing vCards, and how it relates to list_vcards/delete_vcards, so it is not complete enough for correct invocation in edge cases.

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% across all 18 parameters, including the API-specific work_time format and metro_station_id reference, so the schema carries the semantics well. The description contributes no additional parameter meaning (e.g., which address fields are jointly required), which makes the baseline 3 correct.

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

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

The description names a specific verb ('Создать') and resource ('виртуальную визитку') and adds scope ('для кампании'), so the agent knows this creates a vCard bound to a campaign. It does not, however, differentiate itself from siblings such as list_vcards or delete_vcards, which is what would be needed for a 5.

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

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

There is no when-to-use guidance, no statement of prerequisites (e.g., that an existing campaign_id is required), and no mention of the related list_vcards/delete_vcards siblings. The agent must infer everything about applicability 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 declare readOnlyHint=false and openWorldHint=true, so the agent knows this is a write against external state. The description adds the region-targeting nature of the created entity, but says nothing about required permissions, whether the parent campaign must pre-exist, or failure modes.

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

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

One compact sentence with the verb front-loaded and no filler. It could be marginally improved by making the get_regions cross-reference more actionable, but there is no waste.

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, annotations covering the write/safety profile, and no output schema to explain, the description is nearly sufficient. It still omits prerequisites (existing campaign) and confirmation/return behavior, leaving a modest gap for a mutating tool.

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

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

Schema description coverage is 100% and the schema itself is unusually rich (region_ids documents the get_regions format, negative-region rules, and the '0' special case). The description adds no parameter meaning beyond the schema, so the baseline 3 applies.

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

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

The description states a specific verb (create) and resource (ad group) plus its embedding context (inside a campaign) and the region-targeting angle, which distinguishes it from the generic campaign/keyword siblings. It does not explicitly contrast with siblings like create_campaign or create_text_ad, but the scope 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?

It points the agent to get_regions as the source for region codes, which is genuinely useful for populating region_ids. Beyond that, there is no statement of when to use this versus create_campaign or other creation tools, and no listed prerequisites or exclusions.

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

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

Annotations mark it as a non-read-only, open-world mutation but say nothing about risk. The description adds critical context beyond annotations: no test environment exists, the campaign lands in a production account, and it starts spending real money only after moderation and enabling – plus the draft mitigation. This is exactly the kind of behavioral disclosure the annotations cannot convey.

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

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

Three short sentences with the purpose first and the risk warning given prominence via the ⚠️ marker. Every sentence carries weight; only the 'budget in rubles' line is slightly redundant with 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 mutation tool with 8 parameters and no output schema, the description covers the biggest missing piece: the production/no-sandbox risk and the draft workaround. It does not mention what the call returns (e.g., the new campaign ID), which matters for chaining, but the schema otherwise carries the parameter burden.

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

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

Schema description coverage is 100%, so the schema already documents all 8 parameters in detail, including enums and defaults. The description only adds 'budget in rubles', which the schema also states for daily_budget, so it adds essentially nothing beyond structured fields. 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: 'Создать новую рекламную кампанию' clearly distinguishes it from update_campaign and get_campaign. However, it offers no explicit sibling differentiation or scope details, so it is clear but not exceptional.

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

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

The description implies when to use it (creating a campaign to test should be left as a draft) and gives one precautionary usage note. But it never names alternatives or states when-not to use it (e.g., duplicate name handling, prerequisites). Usage is implied rather than explicitly framed.

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, signaling a write to an external system. The description adds no behavioral context beyond the schema's character limits — nothing about permissions, side effects, 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?

A single front-loaded sentence with a colon-separated field list — no wasted words. Efficient, though 'ссылка' omits the constraint the schema carries for href.

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 definition should say more — e.g., that the ad group must exist or what a successful create returns. The schema fully covers the inputs, but the description leaves the agent without return or prerequisite context.

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

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

Schema description coverage is 100%, so all five parameters are already documented with names and length limits. The description's field list and limits only restate what the schema provides, adding no new syntax or meaning. 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 ('текстовое объявление') and enumerates the content fields, so the agent knows exactly what is produced. The create-vs-update distinction against update_text_ad follows from the verb, but the description never names the sibling or otherwise differentiates 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/when-not guidance, no mention of the alternative update_text_ad for edits, and no prerequisites such as the target ad group having to exist. The agent gets no routing help beyond the tool name.

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

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

Annotations already declare destructiveHint=true and readOnlyHint=false, so the safety profile is largely covered. The description adds the useful nuance that deletion is irreversible ('⚠️ Необратимо'), but does not describe permissions, side effects, or failure 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 two short, front-loaded clauses with zero waste. The irreversible warning is clearly separated and easy to notice.

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

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

For a simple one-parameter destructive tool with no output schema, the description plus annotations provide enough to invoke it safely. The main gap is the absence of usage guidance, but annotations already cover the safety-critical behavior.

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

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

Schema description coverage is 100%, and the single parameter's type, pattern, array bounds, and meaning are fully documented in the schema. The description only restates that deletion is by ID, adding 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 states a specific verb and resource ('Удалить уточнения' / delete ad extensions) and identifies the key input ('по ID'). It is clearly distinguishable from sibling operations such as list_ad_extensions and add_ad_extensions.

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 use this tool versus alternatives, nor any exclusions or prerequisites. The deletion intent is implied by the name, but the description adds no routing or contextual usage information.

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 and readOnlyHint=false, so the irreversibility warning largely repeats structured data. Still, the explicit ⚠️ Необратимо makes the consequence impossible to miss, which is useful for a destructive tool, though it adds nothing about auth, batch limits, or partial-failure behavior.

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

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

Two short sentences front-loading the action and resource, with the risk warning immediately after. Nothing redundant or padded.

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

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

For a 1-parameter destructive tool with no output schema, the description covers the action and the irreversibility well, but says nothing about what happens on nonexistent IDs, whether deletion is partial or atomic, or what the agent should verify before calling. Annotations cover the safety profile, so the remaining gap is moderate rather than severe.

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%: the ad_group_ids parameter and its items are already documented with pattern and minItems constraints, and the schema even repeats the irreversible wording. The description adds no syntax or format detail beyond the schema, so baseline 3 applies.

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

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

States a specific verb (Удалить) and resource (группы объявлений), scoped by ID. The sibling set contains list_ad_groups, create_ad_group and update_text_ad-style group tools, so naming the deletion action and its keying by ID clearly separates it from sibling operations.

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 deletion is by ID, implying the tool is for removing already-known ad groups, but it never states when to choose it over list_ad_groups or other ad-group tools, nor any prerequisites. Usage is only implied through the resource and ID scoping.

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. The description adds meaningful context: the bid is reset to base and deletion is irreversible. This exceeds what the annotations alone convey, though it doesn't mention auth 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?

Two short sentences: the action first, then the consequence/irreversibility. No filler, well front-loaded.

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

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

For a destructive single-parameter tool with rich annotations and full schema coverage, the description covers the key behavioral facts (bid reset, no undo). It could mention the maxItems limit or batch nature, but annotations and schema carry most of the remaining burden.

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 adjustment_ids including pattern, bounds, and the hint to source IDs from get_bid_adjustments. The description adds no parameter 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?

States a specific verb+resource (delete bid adjustments by ID) and clearly distinguishes itself from siblings get_bid_adjustments, add_bid_adjustments, and set_bid_adjustments. It does not explicitly name those siblings, but the delete semantics are unambiguous.

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

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

The description implies usage (delete by ID, references get_bid_adjustments in the schema) but does not explicitly state when to use this tool versus set_bid_adjustments or when not to. Usage is inferable from the verb but not 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 declare destructiveHint=true and readOnlyHint=false, so the agent knows this is destructive. The description adds valuable non-obvious context: deletion is irreversible, and per-item failures are returned in the response list rather than as a tool error. This partial-failure semantics is genuinely useful behavioral detail 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 dense sentence covering both the operation and partial-failure behavior. Front-loaded with the action. No wasted words, though could be slightly clearer with punctuation.

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 annotations cover the destructive safety profile and no output schema exists, the description adequately covers core behavior including partial-failure semantics. However, it does not state what permissions are needed or exactly how the failure list is structured in the response, leaving some gaps for a destructive mutation with no output schema.

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

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

Schema description coverage is 100%, so the schema fully documents the single parameter (array of retargeting condition IDs, min 1, max 1000). The description mentions deletion by ID but adds no extra syntax or constraints beyond what the schema provides. Baseline 3 applies when schema does the heavy lifting.

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

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

States a specific verb (удалить) and resource (условия ретаргетинга и подбора аудитории), and specifies deletion is by ID. Clearly distinguishable from siblings like add_retargeting_list, update_retargeting_lists, list_retargeting_lists.

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?

Implies deletion semantics and irreversibility, but does not explicitly state when to use this versus update_retargeting_lists or how to discover IDs. The ID source is noted in the schema (list_retargeting_lists), not the description. Usage is implied rather than guided.

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

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

Annotations already declare destructiveHint=true and readOnlyHint=false, so the safety profile is covered. Beyond that, the description discloses a concrete behavioral guardrail — that Direct will refuse to delete a sitelink set bound to an ad — which is genuine value not present in the annotations or 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 short sentences, front-loaded with the action and resource, followed immediately by the key constraint. No filler.

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

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

For a single-parameter destructive tool with no output schema and annotations covering the safety profile, the description is almost complete: it names the resource, the identifier source, and the one behavioral gotcha. It lacks only a note on the outcome/error behavior when deletion is blocked.

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 array parameter is fully documented ('ID набора быстрых ссылок', sourced from list_sitelinks). The description adds nothing beyond what the schema already conveys, so the baseline of 3 applies.

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

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

States a specific verb and resource ('Удалить наборы быстрых ссылок по ID' / delete sitelink sets by ID), which an agent can distinguish from the sibling set_sitelinks (create/attach) and list_sitelinks (read). The scope 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 description adds a useful contextual condition ('a set attached to an ad cannot be deleted'), which implicitly hints at a precondition, but it never states when to prefer this tool over alternatives or how to resolve the blocked-deletion case (e.g., unlink first). Usage is implied rather than guided.

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

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

Annotations already declare destructiveHint=true and readOnlyHint=false, so the description is not the sole carrier of the safety profile. It nonetheless adds genuinely useful behavior beyond them: irreversibility is stated explicitly, and per-vcard failures surface as a list in the response rather than as a call error — a non-obvious contract worth knowing.

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 clauses, no filler, with the destructive/irreversible nature and the unusual error semantics both front-loaded. Every sentence earns its place.

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

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

With no output schema, the description admirably covers the key return-behavior quirk (partial failures returned as a list, not an error). It does not discuss the 10000-item limit or atomicity across the whole batch, but it is complete enough 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% and there is only one parameter, so the schema already documents that vcard_ids come from list_vcards and enforces the ID pattern. The description's 'по ID' adds nothing new; 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 ('Удалить визитки по ID'), making it immediately distinguishable from the delete siblings (delete_ad_groups, delete_sitelinks, delete_ad_extensions) and paired with list_vcards.

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

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

The tool's usage is implied by 'delete by ID', and the schema points to list_vcards as the ID source, but the description names no alternatives or conditions (e.g., how to delete a single vcard vs many, or when to prefer other tools). Minimum viable.

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

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

Annotations already declare readOnlyHint=true and openWorldHint=true, so the agent knows the safety profile without the description. The description adds that data comes through Live API v4 and what fields are returned, but says nothing about auth requirements, rate limits, or behavior for multiple logins.

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 compact sentence with the resource front-loaded and no filler. It is perhaps slightly terse to the point of omitting useful context, 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?

With no output schema, the description does useful work by naming the returned fields (Amount, Currency). However, for a financial-query tool it omits how the optional logins array affects the response shape and any limits on how many accounts can be queried at once.

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 optional 'logins' parameter is documented in the schema itself (agency-token logins, defaults to the token's own account). The description adds nothing about parameter semantics, so the baseline 3 applies.

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

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

States a specific verb and resource ('Баланс и финансовая информация аккаунта') and even names the returned fields (Amount, Currency), which is more than most sibling names imply. It does not explicitly differentiate itself from sibling read tools such as get_statistics, but the resource 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?

No indication of when this tool should be used versus alternatives, no prerequisites, and no note about whether an agency token context changes the call. The only usage hint is buried 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=true and openWorldHint=true, so the safety profile is covered externally. The description adds that results span several targeting dimensions, but says nothing about pagination, default limits, or ordering, which is the behavior an agent would still wonder about.

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

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

A single front-loaded sentence that opens with the action and immediately lists what is returned. Efficient, though the trailing category enumeration is somewhat long.

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 paginated read with no output schema, the description covers the domain well but omits pagination behavior and how the levels/ad-group/campaign parameters interact. Annotations cover safety, and the schema covers parameter mechanics, so the gap is moderate rather than severe.

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 seven parameters are already documented in the schema. The description's category list loosely maps to the types enum but adds no syntax or format detail beyond it, making the baseline 3 appropriate.

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

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

The description names a specific verb (Получить = Get) and resource (bid adjustments), and scopes it to campaign or ad-group level while enumerating the adjustment families (devices, gender/age, audiences, regions, income, placement). The read verb implicitly separates it from set/add/delete siblings, though it never names 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?

It states only what is returned, with no indication of when to call this versus add_bid_adjustments/set_bid_adjustments/delete_bid_adjustments or any workflow context such as reading current adjustments before modifying them. Usage is left entirely to inference from the verb.

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

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

Beyond the readOnly/openWorld annotations, the description discloses non-obvious behavior: MCBANNER campaigns come back empty by ID, empty results do not mean an invalid ID, and the GoalId 13 strategy sentinel semantics. These are exactly the caveats that prevent misdiagnosis of a successful 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?

Purpose is front-loaded and the field list plus caveats each carry information; nothing is filler. It is somewhat dense and long, but the length is justified by the domain-specific edge cases.

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

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

No output schema exists, so the description must carry the return shape, and it does so comprehensively (fields returned, nested PriorityGoals semantics, attribution, counters). Combined with the empty-response and MCBANNER caveats, an agent has everything needed to call and interpret this tool.

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

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

Only one parameter and schema coverage is 100%, so the schema already documents campaign_id fully (pattern, decimal string). The description's ID-related notes concern interpreting output (PriorityGoals.Items[].GoalId) rather than adding syntax for the input, 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+resource ('детальная информация о кампании по ID') and then enumerates the returned content (budget, status, dates, stats, UTM, PriorityGoals, Metrica counters, attribution). The 'по ID' scope makes it clearly distinct from list_campaigns in the sibling set.

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 results appear empty (MCBANNER campaigns are not returned by the API) and warns that an empty response does not imply a bad ID, which is real usage guidance. It does not, however, explicitly route the agent to list_campaigns to obtain an ID.

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

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

Annotations already declare readOnlyHint=true and openWorldHint=true, so the agent knows this is a safe read. The description adds only the word 'текущие' (current), which hints the result reflects live state, but says nothing about pagination, result size, or what happens with unknown IDs.

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 short, front-loaded sentence with no waste. It is tightly scoped, though its brevity borders on under-specification for a retrieval tool.

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

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

With one parameter, 100% schema coverage, and annotations covering the safety profile, the essentials are present. However, with no output schema, the description leaves the agent guessing about the shape and volume of the returned negative-keyword data.

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 there is a single well-documented parameter, so the baseline is 3. The phrase 'по их ID' merely restates the campaign_ids parameter without adding format or constraint 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 states a specific verb and resource ('получить минус-фразы кампаний'), so an agent knows it reads campaign-level negative keywords. It is distinguishable from the sibling set_campaign_negative_keywords, 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, no mention of prerequisites (e.g., needing campaign IDs that already exist), and no routing to alternatives such as list_keywords or set_campaign_negative_keywords. Usage is only implied by the verb.

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

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

Annotations already declare readOnlyHint=true and openWorldHint=true, so the safety profile is covered. The description adds one genuinely useful behavioral fact — that dictionaries mode returns only the current server time when timestamp is omitted — but omits return shape, limits (e.g. maxItems 50000) or rate-limit behavior.

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

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

A single front-loaded sentence that leads with the primary resource set and appends the dictionaries special case. No filler, though cramming three distinct modes into one clause reduces scannability slightly.

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 6-parameter, mode-driven tool with no output schema and no return-value documentation, the description covers the modes but not what the response contains or how field_names interacts with the ID filters. Adequate but leaves meaningful gaps for a polling/change-detection tool.

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

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

Schema description coverage is 100%, so the schema already documents mode, timestamp requirement per mode, and each ID list. The description largely restates the mode=dictionaries behavior rather than adding new semantics, so the baseline of 3 is appropriate.

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

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

States a concrete verb ('Проверить изменения') and the resources covered (campaigns, groups, ads, dictionaries), and explicitly names mode=dictionaries. It is distinguishable from siblings like get_statistics or list_campaigns, though the mapping to the 'objects' mode is left implicit.

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

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

Usage is implied: use it to poll for changes since a given time. However, it never says when to prefer this over sibling reads such as get_campaign/get_statistics, nor does it state exclusions or prerequisites (e.g. that it is a change-feed rather than a full fetch).

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 readOnlyHint and openWorldHint. The description adds real behavioral context beyond them: all values are in rubles, what Bid vs Price mean, and the critical caveat that autostrategy campaigns (WB_*, AVERAGE_CPA/CPC) make bidding inapplicable. It does not discuss pagination behavior, which is a minor gap.

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

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

Dense and front-loaded, leading with what is returned before scoping and caveats. It is long, but nearly every clause carries operational value; the position-range enumeration is the only slightly verbose stretch.

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, so the description carries the burden of explaining return fields (Bid, Price, positions, currency) and does so thoroughly, plus it covers the manual-vs-autostrategy prerequisite. 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 coverage is 100%, so the baseline is 3, but the description adds meaning the schema does not: the three ID-array parameters are mutually exclusive by level ('отбор по одному уровню'), which tells the agent not to combine keyword_ids, ad_group_ids, and campaign_ids.

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 resource and scope: auction pricing (Bid/Price) per position P11–P14 and P21–P24, competitor bids and minimum entry price. It also distinguishes itself from set_keyword_bids and get_strategy by naming them and the condition that separates them.

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

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

Explicitly says selection works at one level (keywords, groups, or campaigns), that price is viewable for any campaign but bidding only applies under manual management, and routes the agent to get_strategy to check, noting set_keyword_bids is useless under autostrategies. When-to-use, when-not, and alternatives are all present.

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?

readOnlyHint and openWorldHint already declare the safe, external-read nature, so the safety profile is covered. The description adds useful domain facts beyond annotations — the magic code 225 = Россия and that with_parents distinguishes same-named cities — but return/pagination behavior is left to be inferred.

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, front-loaded fragments with no filler: resource first, then filter hint, then the with_parents behavior. Efficient and easy to scan, though telegraphic rather than fully structured.

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 reference lookup with 100% schema coverage and no output schema, the description supplies enough context (what the regions are, the key code, the special with_parents toggle). Nothing essential to a correct call is missing, though a note on result shape would round it out.

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, making 3 the baseline. The description largely restates the with_parents semantics already present in the schema; the 225 = Россия fact is extra context but not tied to a specific 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 names the resource concretely — a reference of region codes (GeoRegions) — and frames its purpose (для таргетинга), so an agent knows this is a lookup tool rather than a campaign mutator. It does not explicitly contrast itself with any sibling, but the resource is clear enough to disambiguate from the surrounding campaign 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: 'для таргетинга' and 'Фильтр по названию' suggest when the tool is relevant, but there is no explicit when-to-use/when-not and no named alternative (e.g. get_time_targeting or get_campaign). Adequate but leaves the agent to infer the trigger 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 already declare readOnlyHint=true and openWorldHint=true, covering the safety profile. The description adds only that queries are 'actual' but omits pagination, authentication, response format, or other behavioral traits beyond what annotations provide.

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

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

The description is a single, front-loaded sentence with no filler or redundancy. Every word contributes to stating the tool's purpose and use case.

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 report tool with fully documented parameters and safety annotations, the description conveys the core purpose. However, it omits usage details and expected output information, and since there is no output schema, more context could have been provided.

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

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

With 100% schema description coverage, the schema fully documents all four parameters, including the optional fields list and date formats. The description provides no additional parameter meaning, so the baseline of 3 is appropriate.

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

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

States a specific verb (report) and resource (actual search queries) with its analysis purpose, distinguishing it from keyword-management siblings. However, it does not explicitly name alternative tools for related tasks, so it falls short of a 5.

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

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

The description gives a clear use case: for analyzing search queries and adding negative phrases. It provides context but does not mention when to use alternatives or any exclusions, so 4 rather than 5.

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

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

Annotations already declare readOnlyHint=true and openWorldHint=true, so the safe-read nature is covered structurally. The description adds useful context beyond that: money is returned in rubles, output is TSV, and the backing service is ReportService. It does not disclose limits on campaign count, date-range constraints, or any 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?

A single dense sentence with the resource and metric list front-loaded and no filler. The trailing '(ReportService, TSV)' parenthetical is compact and informative, though slightly implementation-flavored for a description.

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 does double duty and partially covers it by listing the metric columns and the TSV format. However, it omits how many campaigns can be queried at once, any date-range limits, and whether results are aggregated or per-day, leaving gaps for a reporting tool.

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

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

Schema description coverage is 100% (all four parameters documented, including default fields and the ruble note), so the schema carries the parameter burden. The description's 'расход (руб)' only echoes what the schema already states about currency. 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+resource ('Статистика кампаний за период') and enumerates the metrics returned (показы, клики, расход, CTR, CPC). It is clearly distinguishable from sibling tools like get_campaign or list_campaigns, which manage entities rather than report metrics. No explicit sibling differentiation is needed here since none of the siblings are statistics 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?

There is no statement of when to use this tool versus alternatives, no prerequisites (e.g. campaign must exist), and no exclusions. The period and campaign scope are implied only by the required parameters, not by the description text.

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

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

Annotations already declare readOnlyHint=true and openWorldHint=true, so safety is covered. The description goes further with non-obvious domain behavior: that GoalId in BiddingStrategy can be a service value (13 = key goals, 12 = engaged sessions) and that the Direct API never returns goal names. This is real added context 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 purpose is front-loaded in the first sentence, followed by dense but relevant detail on return fields and the service-GoalId gotcha. Slightly long for a one-parameter read, but every sentence carries domain value rather than 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 carries the burden of explaining returns and does so with concrete field paths (TextCampaign.PriorityGoals.Items[].GoalId, CounterIds) and the Value-in-rubles detail. Coverage is strong; pagination/error behavior is not addressed but is minor for this 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 100% for the single campaign_id parameter, so the schema already documents it fully. The description adds nothing about the parameter itself, matching the baseline-3 rule when the schema does the work.

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

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

States a specific verb ('Получить') and resource (current impression strategy of a text-graphic campaign) and enumerates what comes with it: PriorityGoals, counters, attribution model. An agent can immediately tell this apart from set_strategy and from get_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?

Usage is only implied: it reads the current strategy, so it is the read-side counterpart of set_strategy. There is no explicit when-to-use/when-not guidance and no named alternative for the cases where get_campaign would suffice.

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

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

Annotations already declare readOnlyHint=true and openWorldHint=true, so the safety profile is covered. The description adds no behavioral context beyond that — no mention of permissions, rate limits, or response shape — but it does scope what the resource contains, which is mild added value.

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

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

A single compact sentence with the resource stated first and no filler. It is well front-loaded, though as a fragment it stops short of fully specifying the tool's 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?

With no output schema, the description usefully enumerates the fields the resource exposes (time zone, weekday hours, hourly coefficients, holidays), effectively standing in for a return-value description. For a one-parameter read-only getter this is close to complete; only the retrieval framing 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% with a single documented campaign_id parameter (pattern and format included), so the schema already carries the semantics. The description adds nothing about the parameter, making the baseline 3 appropriate.

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

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

The description names a specific resource (campaign time targeting) and enumerates its components: time zone, display hours per weekday, hourly coefficients, and holiday settings. Combined with the get_ prefix it is distinguishable from the sibling set_time_targeting, but the description never states the retrieval action explicitly — it is a noun phrase describing the resource rather than a verb+resource statement.

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

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

There is no guidance on when to use this tool versus set_time_targeting or the other campaign getters, and no prerequisites (e.g. needing campaign_id to exist) are mentioned. The read-only nature must be inferred entirely from the name and annotations.

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 cover readOnly=false, idempotent=true and openWorld=true, but the description adds real behavioral context: bindings are replaced (not appended), campaign-level bindings cascade to all its ad groups, and an empty set_ids clears them. It also notes that campaign type is read server-side, causing an extra API call — a useful cost hint not present in structured fields. Missing only permission/error behavior.

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

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

Three short, front-loaded sentences with zero filler; the replacement semantics come first and each subsequent sentence adds a distinct behavioral fact.

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 annotation coverage, full schema descriptions and no output schema, the description supplies the key destructive/cascade/clearing semantics an agent needs. It stops short of routing guidance against the many sibling negative-keyword tools, which is the one notable gap.

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

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

Schema description coverage is 100%, so all three parameters are already documented in the schema, including maxItems and the destructive-replacement note. The description only reinforces the empty-set_ids behavior already stated in the schema, adding no new syntax or format detail.

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 ('Заменить привязки общих наборов минус-фраз') plus the two target scopes (кампаний и/или групп объявлений). This clearly separates it from sibling tools like set_campaign_negative_keywords and set_ad_group_negative_keywords, which operate on individual keywords rather than shared sets.

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?

Explains the operational semantics (campaign-level binding cascades to all ad groups, empty set_ids clears), which implies usage, but never states when to choose this over manage_negative_keyword_shared_sets or the per-level negative keyword tools. No alternatives or prerequisites are named.

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

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

Annotations already declare readOnlyHint=true and openWorldHint=true, so the safety profile is covered. The description adds that returned items include statuses and text, but says nothing about pagination behavior despite limit/offset parameters, leaving a meaningful gap for a list tool with no output schema.

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

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

A single short, front-loaded sentence with no filler. It is efficient, though arguably too terse to earn full marks given the tool's five-parameter surface.

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 five-parameter, zero-required list tool with no output schema and only readOnly/openWorld annotations, the description is minimal. It hints at return content (statuses and text) but omits pagination behavior and the relationship between the states and statuses filters, leaving the agent to rely wholly on 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%, so every parameter (limit, offset, states, statuses, ad_extension_ids) is already documented in the schema. The description adds no syntax, format, or filter semantics beyond that, so the baseline of 3 applies.

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

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

The description states a specific verb ('Получить') and resource ('уточнения (callouts)'), and the bilingual gloss disambiguates the term. It does not explicitly distinguish itself from the add_ad_extensions/delete_ad_extensions siblings, but the read/list nature is clear from the name and description together.

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 offers no guidance on when to use this tool versus alternatives such as add_ad_extensions, delete_ad_extensions, or the sitelink listers. No prerequisites or exclusions are stated; usage must be inferred entirely from the name.

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

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

Annotations already declare readOnlyHint=true and openWorldHint=true, so the safe-read nature is covered by structured data. The description adds that results are scoped to selected campaigns and enumerates returned fields, which is modest extra context but doesn't discuss pagination or result size limits beyond what the schema covers.

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, front-loaded with the resource and scope. Nothing wasted, though the field list is a bit thin for the space allotted.

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

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

For a read-only list tool with full schema coverage and annotations covering safety, the description is minimally adequate. It lacks explicit guidance on pagination behavior, expected result volume, or how it relates to sibling list tools, but nothing essential for a correct call is missing.

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

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

Schema description coverage is 100%, so all three parameters (campaign_ids, limit, offset) are already documented in the schema, including pagination semantics for offset. The description adds no parameter-level detail beyond what the schema provides, so baseline 3 applies.

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

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

States verb+resource: lists ad groups of selected campaigns and the fields returned (names, regions, statuses). Clear purpose, though it doesn't explicitly distinguish itself from sibling list tools like list_campaigns or list_ads beyond the resource name itself, which is fairly self-evident.

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 guidance, no prerequisites, no mention of alternatives. The agent must infer from the name alone that this is the read-side complement to create_ad_group/delete_ad_groups.

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 readOnlyHint/openWorldHint annotations, it discloses two non-obvious behavioral traits: the result set silently omits ads whose copy is neural-network generated (and no signal of this appears in the response), and the moderation rejection reason surfaces in StatusClarification. This is exactly the kind of context annotations cannot carry, and it warns the agent not to infer absence from the output.

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?

Dense but front-loaded: the returned fields come first, then the filtering constraint, then the incompleteness caveat. Every sentence carries information, though the paragraph is heavy and the caveat about neural-network ads could be tightened without losing meaning.

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

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

With no output schema, the description carries the return-value burden and does so: it names the fields, where the rejection reason lives, and critically warns that the list can be incomplete in a way invisible to the caller. An agent has everything needed to call and correctly 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 the schema already documents limit, offset and ad_group_ids. The description adds a genuine constraint not in the schema: ad_group_ids is the only selector and ad-ID lookup is not supported, which clarifies how the parameter must be used.

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 (listing ads within ad groups) and enumerates the returned fields (titles, texts, links, statuses, type/subtype, sitelinks, vcard, image). It is clearly distinguishable from write-oriented siblings like manage_ads, moderate_ads and create_text_ad, and from list_ad_groups by its resource scope.

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

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

Gives clear scoping rules — selection is by group only, not by ad ID, and archived ads are returned alongside active ones — plus a caution to cross-check the Direct UI for completeness. It stops short of explicitly naming a sibling alternative for other lookup modes, but the context for when this tool applies is unambiguous.

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

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

Annotations already declare readOnlyHint=true and openWorldHint=true, so the safety profile is covered. The description adds nothing further — no pagination behavior, no indication of whether multiple filter IDs are combined with AND or OR, and no note on result size.

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 wasted words; the verb and the filter dimensions arrive immediately.

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

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

For an 8-parameter listing tool with no output schema, the description omits how results are returned, how paging works (the offset/limit pair is only explained inside the schema), and whether supplying no filter IDs is valid. Given no annotations beyond read/open-world, this is 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 description coverage is 100%, so every parameter (limit, offset, states, and the five ID-array filters) is already documented in the schema. The description's mention of campaign/group/retargeting/interest IDs mirrors the schema rather than extending it, 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 ("условия нацеливания на аудиторию"), plus the four ID dimensions it can be queried by. It does not explicitly name the sibling set_audience_targets, but the get-vs-set distinction is readable from the name and title.

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, no statement of prerequisites (e.g. at least one filter ID), and no pointer to set_audience_targets for modifications or to list_retargeting_lists for resolving list IDs. Usage must be inferred entirely from the verb.

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

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

Annotations already declare readOnlyHint=true and openWorldHint=true, covering the safety profile. The description adds only that profiles are 'доступные' (available), which hints at access scoping, but does not disclose pagination, rate limits, or return format. With annotations covering the basics, this is a minimal addition. Score 3.

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

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

A single sentence with no wasted words, front-loading the verb and resource. Appropriately sized for the tool's simplicity. Score 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 a list tool with three optional parameters, no output schema, and annotations covering safety, the description is adequate but minimal. It does not explain pagination or the shape of returned profiles, leaving some gaps. Score 3.

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 input schema. The description adds no parameter-level meaning beyond what the schema provides. Baseline 3 applies.

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

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

The description states a specific verb ('Получить') and resource ('доступные профили организаций из Яндекс Бизнеса'), making the tool's purpose clear. It does not explicitly differentiate from sibling tools, but the domain (business profiles) is unique among the siblings. Score 4.

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

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

No guidance is provided on when to use this tool versus alternatives or in what contexts. The description only says what it does, not when to invoke it. Score 2.

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

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

Annotations already cover the safety profile (readOnlyHint, openWorldHint), so the description goes beyond by disclosing a non-obvious behavioral boundary: MCBANNER campaigns are absent by API design, not by filter or auth failure — an important trap for an agent. It also discloses currency units and the default projection, though it says nothing about rate limits or result caps beyond the schema.

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

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

Four sentences, front-loaded with purpose then progressively adding field behavior and the API-boundary caveat. Each sentence carries information, though the default-field enumeration slightly overlaps the 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?

With no output schema, the description compensates by stating what is returned by default, how to widen the projection, and which campaigns will never appear. For a 5-parameter, read-only list tool this covers everything an agent needs 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 coverage is 100%, so the baseline is 3, but the description adds real meaning: budgets are denominated in rubles (relevant to DailyBudget/Funds), the default returned field set, and the purpose of 'fields'. The default-field list is partly duplicated from the schema, keeping it from a 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 and resource ("Список рекламных кампаний Яндекс.Директ") plus the supported filter dimensions (status and type). The plural 'список' clearly separates it from the singular get_campaign sibling without needing further contrast.

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?

Explains how to operate the tool: default field set applies, and other CampaignFieldEnum fields must be requested explicitly via 'fields'. It also sets expectations that MCBANNER campaigns are never returned. It lacks explicit when-to-use-vs-alternative routing (e.g. vs get_campaign or manage_campaigns), so it stops short of a 5.

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

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

Annotations already declare readOnlyHint=true and openWorldHint=true, so the safety profile is covered. The description adds no behavioral context such as pagination behavior, authentication needs, rate limits, or what happens with large limits/states filters. It only restates the purpose.

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

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

A single front-loaded sentence that states the action and resource with no filler, repetition, or wasted words. It is appropriately sized for its scope.

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

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

For a six-parameter list tool with no output schema, the description lacks routing information to separate it from manage_dynamic_targets and does not summarize return content or filtering behavior. Although the schema and annotations provide structured details, the description itself is too thin to fully guide selection and invocation.

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

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

Schema description coverage is 100%, so all six parameters (limit, offset, states, ad_group_ids, campaign_ids, dynamic_target_ids) are fully documented in the schema. The description does not mention any parameters or add semantic meaning beyond what the schema provides, warranting the baseline 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 'Получить' (get) and a clear resource 'условия нацеливания динамических текстовых объявлений' (targeting conditions of dynamic text ads). It does not explicitly differentiate from the sibling manage_dynamic_targets beyond the tool name, but the purpose is otherwise clear.

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

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

No guidance on when to use this tool versus manage_dynamic_targets or list_audience_targets. There are no exclusions, prerequisites, or context signals in the description; usage must be inferred entirely from the name and sibling list.

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

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

Annotations already declare readOnlyHint=true and openWorldHint=true, so the safety profile is covered. The description adds useful context about what data is returned (sources, processing statuses, related campaigns), but says nothing about pagination, filtering behavior, or result limits beyond what the schema implies.

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, efficient sentence with no filler and the resource front-loaded. It is appropriately sized, though minimal enough that it leaves room for additional usage 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 read-only list tool with annotations covering safety and 100% schema coverage, the essentials are present. However, with no output schema, the description's brief enumeration of returned fields is thin and pagination behavior (offset/LimitedBy) is 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 description coverage is 100%, so limit, offset, and feed_ids are already fully documented in the schema. The description adds no additional parameter meaning or syntax, matching the baseline 3 when the schema does the heavy lifting.

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

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

States a specific verb ('Получить') and resource ('товарные фиды') and enumerates what it returns (sources, processing statuses, related campaigns). No sibling tool covers feeds, so there is no alternative to disambiguate from, but the scope is clear.

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

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

The description offers no when-to-use guidance, prerequisites, or conditions. It only describes output content, leaving the agent to infer that this is the unfiltered account-level feed listing on its own.

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

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

Annotations already declare readOnlyHint=true and openWorldHint=true, so the safety profile is covered. The description adds useful behavior beyond that: a narrow default field set is returned unless the caller expands it via fields. It does not mention pagination or return shape, but with annotations present a 3 is appropriate.

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

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

Two compact sentences with the resource and purpose front-loaded, followed by the field-selection caveat. No wasted words, though the parenthetical field examples are borderline redundant against the enum 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 read-only filtered-list tool with full schema coverage and no output schema, the essentials are present. However, it omits pagination/offset behavior and does not clarify how results relate to sibling listing tools, leaving modest gaps.

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

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

Schema coverage is 100%, so both the fields enumeration and the default field list are already documented in the schema. The description reinforces this by naming KeywordFieldEnum and example fields, but adds little the schema does not already provide. Baseline 3 applies.

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

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

The description states a specific verb and resource: keywords ("ключевые фразы") in ad groups, with the returned data types (phrases, bids in rubles, statuses). It is clearly a read/list operation distinguishable from add_keywords/update_keywords, though it does not call out those siblings 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 explicit when-to-use guidance or reference to alternatives. The agent must infer that this is the read counterpart to add_keywords/update_keywords/manage_keywords purely from the verb in the name; the description provides no conditions, prerequisites, or exclusions.

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

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

Annotations already declare readOnlyHint=true and openWorldHint=true, so the safety profile is covered. The description adds only the account-level scoping, with nothing about pagination behavior, result ordering, or that set_ids narrows the result set beyond the schema text.

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

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

A single front-loaded sentence with zero filler. It is efficient, though arguably under-specified rather than ideally concise for a listing tool.

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

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

For a simple read-only list tool with a fully documented schema and readOnly annotations, the definition is minimally adequate. With no output schema, a note on what a returned set contains would have added value, but nothing essential to invocation is missing.

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

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

Schema description coverage is 100%, so all three parameters (limit, offset, set_ids) are already fully documented in the schema. The description contributes no additional parameter meaning, which is the baseline case.

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 ('общие наборы минус-фраз аккаунта'), so the agent knows exactly what it retrieves. It does not distinguish itself from the sibling manage_negative_keyword_shared_sets (which likely also lists/manages these sets) or from get_campaign_negative_keywords, leaving some ambiguity about scope.

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

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

No when-to-use guidance, no prerequisites, and no mention of alternatives such as the campaign- or ad-group-level negative keyword tools. Usage is only implied by the verb.

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

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

Annotations already declare readOnlyHint=true and openWorldHint=true, so the agent knows this is a safe, potentially unbounded read. The description adds little beyond restating that it retrieves rules and scope, but doesn't contradict annotations. It fails to disclose pagination limits (though maxItems hints at 10000), rate limits, or output 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?

The description is a single, reasonably concise sentence with no wasted words. However, it is under-specified and front-loads only the general purpose, leaving key details (filtering, pagination) to the schema. It's efficient but lacks informative structure.

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

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

For a read-only list tool with full schema coverage and no output schema, the description covers the basic purpose but omits important context: that it supports filtering by type and specific IDs, and that it may paginate. Given the sibling tools include update/delete/add variants, more guidance on distinguishing this as the 'list' operation would improve completeness.

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

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

Schema description coverage is 100%, so the schema fully documents all four parameters including limit, types enum, offset, and retargeting_list_ids. The description adds no parameter-specific information, which is acceptable given the high coverage. Baseline 3 is appropriate.

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

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

The description states a verb ('Получить') and resource ('условия ретаргетинга и подбора аудитории'), which gives a general sense of retrieval. However, it doesn't differentiate from siblings like list_audience_targets, list_dynamic_targets, or list_negative_keyword_shared_sets, all of which are also list operations. The scope is vague about what 'область применения' means in practice.

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 tool versus alternatives like list_audience_targets or list_dynamic_targets. There's no mention of prerequisites, pagination behavior, or when filtering by types is appropriate. The agent is left to infer usage context entirely.

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

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

Annotations already declare readOnlyHint=true and openWorldHint=true, so the safety profile is covered. The description adds nothing beyond that — no note on pagination behavior, result volume, or permissions. It does not contradict the annotations, but contributes very little behavioral context.

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 that is front-loaded with the action and contains no filler. It is efficient, though its brevity is partly the source of the missing usage and behavioral detail.

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

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

For a read-only list tool with zero required parameters, fully documented schema, and no output schema, the description is minimally sufficient. Annotations cover the safety profile, but nothing addresses result ordering or pagination beyond the offset parameter's own 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 description coverage is 100%, so limit, offset, and sitelink_set_ids are fully documented in the schema itself. The description's 'all or selected sets' mirrors the optional sitelink_set_ids filter but adds no syntax or format detail. Baseline 3 is appropriate when the schema does the heavy lifting.

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

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

States a specific verb ('Получить') and resource ('наборы быстрых ссылок') and clarifies the all-vs-selected scope. It separates itself from write operations like set_sitelinks/delete_sitelinks by verb alone, but never explicitly names a sibling, so it falls short of a 5.

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

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

There is no guidance on when to use this tool versus alternatives such as list_ad_extensions or set_sitelinks, no prerequisites, and no conditions. The 'all or selected' phrasing hints at filtering but is a description of scope, not usage guidance.

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

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

Annotations already declare readOnlyHint=true and openWorldHint=true, so the safety profile is covered. The description adds only the consumer context (set_time_targeting, create_campaign) and the filter capability; it does not cover the 50-item default limit behavior, pagination, or result size, which would be valuable given the maximum of 500.

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 resource and followed by the filter capability. Efficient, though the consumer list could be integrated more tightly and the sentence stops short of stating the retrieval action.

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

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

For a simple two-parameter read-only lookup with no output schema, the essentials (resource, filter, consumers) are present. But the description omits the default limit of 50 and the maximum of 500, which materially affect how an agent should call it, and does not clarify its relationship to get_regions.

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

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

Schema description coverage is 100%, with both limit (default 50, max 500) and search (substring, case-insensitive, examples) fully documented in the schema. The description merely echoes the filter capability ('Фильтр по коду или названию') without adding format or syntax beyond what the schema already provides.

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

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

States a specific resource (time zone reference list) and its consumers (set_time_targeting, create_campaign), which helps position it against siblings like get_regions. However, it describes itself as a 'справочник' (reference/directory) rather than clearly stating the verb (list/retrieve), leaving the action implicit.

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

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

Naming set_time_targeting and create_campaign implies this is a lookup to support those operations, giving useful context. But there is no explicit when/when-not guidance, no mention of the read-only nature in prose, and no differentiation from get_regions, which is a closely related sibling.

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

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

Annotations already declare readOnlyHint=true and openWorldHint=true, so the safety profile is covered. The description adds only the two retrieval modes and nothing about pagination, result caps, or how campaign-based lookup behaves. Given the lower bar set by annotations, a 3 is appropriate.

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

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

A single, front-loaded sentence that names the resource and both retrieval modes with no filler or redundancy. Every clause earns its place.

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

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

For a read-only list tool with four optional parameters fully documented in the schema and clear annotations and no output schema, the description covers the essential access paths. It omits pagination framing and typical result shape, but the schema and annotations carry enough that an agent can call it correctly.

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

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

Schema description coverage is 100%, with limit, offset, vcard_ids, and campaign_ids each documented in the schema itself. The description's mention of IDs and campaign-linked ads adds marginal framing but no syntax or format detail beyond the schema, so the baseline of 3 applies.

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

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

States a specific verb (получить/найти) and resource (виртуальные визитки), and clearly distinguishes itself from the mutation siblings add_vcard and delete_vcards by being a read/list operation. It also names the two distinct retrieval paths (by ID vs. via campaign ads), which helps disambiguate 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 sentence implies the two usage modes — pass IDs directly or select campaigns whose ads carry the vCards — which maps loosely to the vcard_ids and campaign_ids parameters. However, it gives no explicit guidance on when to prefer one path over the other, no prerequisites, and no exclusions, leaving usage inference to the agent.

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 safety profile is covered externally. The description's only added behavioral detail is the base64 encoding requirement for add, which largely duplicates the schema's 'image_data' description; it does not say which action is irreversible or what constraints apply.

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 naming the three actions, followed by one short conditional clause. Both clauses earn their place and there is no filler, though the whole definition is thin for a six-parameter destructive tool.

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

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

For a multi-action tool with a destructive delete branch, the description covers only the add path and omits any framing of the read/filter or delete flows. With no output schema this is acceptable on return values, but the description does not help an agent understand which parameters matter for which action beyond what the schema already spells out.

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 six parameters (action, images, limit, offset, associated, ad_image_hashes) are documented in the schema itself, including per-action applicability and the irreversibility of delete. The description's base64 note adds nothing beyond what 'image_data' already states, 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 resource (AdImages / объявления изображения) and enumerates the three operations (upload, get, delete), so an agent immediately knows this is a multi-action image CRUD tool. It does not need to differentiate from siblings since no other tool in the list touches ad images, but it also makes no explicit contrast.

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 through the action list and the one conditional hint ('Для add данные передаются в base64'). There is no guidance on when to choose get vs delete, no prerequisites, and no exclusions relative to any sibling tool.

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

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

Annotations already declare destructiveHint=true and readOnlyHint=false, but the description adds the pinpointed fact that specifically 'delete' is irreversible (⚠️ delete необратимо), which is genuinely additive over the blanket destructive flag. It still omits permission requirements and what suspend/archive do to live serving, but clears the lowered bar set by annotations.

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

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

Two compact sentences with the action set front-loaded and the destructive caveat attached directly to the dangerous action. No filler; every clause earns its place.

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

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

Adequate for a 2-param mutation tool with full schema coverage and safety annotations, and no output schema to explain. But for a six-action destructive tool it omits what non-delete actions actually change and any preconditions, leaving clear gaps.

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

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

Schema description coverage is 100%, so both 'action' (enum) and 'ad_ids' are fully documented in the schema, including the irreversibility note on delete. The description only restates the enum values already present, adding no syntax or format detail beyond the schema, so baseline 3 applies.

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

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

States a clear verb+resource ('Действие над объявлениями') and enumerates the exact action set, so the agent knows precisely what the tool does. However, it offers no differentiation from the sibling 'moderate_ads', which appears to overlap with the 'moderate' action listed here, nor from delete_ad_groups/list_ads.

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

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

No when-to-use guidance, no prerequisites, and no mention of alternatives. The agent is not told when to pick manage_ads versus moderate_ads or the create/update_text_ad siblings, despite the overlap.

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 and readOnlyHint=false, so the safety class is covered. The description goes beyond them by stating delete is irreversible and, importantly, that it fails for campaigns with accumulated statistics — a real operational constraint the annotations cannot convey.

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

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

Two front-loaded sentences: the action list first, then the warning. No filler, and the emoji flag efficiently surfaces the one destructive 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?

For a batch mutation tool with fully covered params and annotations carrying the destructive profile, the essentials are present. It could mention per-campaign result handling or partial failure behavior, but that is a minor gap with no output schema to lean on.

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 enum values and campaign_ids are already documented, which sets the baseline at 3. The description echoes the action list and adds the delete restriction, but adds little on the campaign_ids container (batch size, ordering, partial behavior) 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 names the resource (campaigns) and enumerates the specific batch actions (start, stop, archive, unarchive, delete), so the agent immediately understands it is a state-change tool. It does not explicitly contrast itself against update_campaign/create_campaign siblings, but the action list is unambiguous enough to distinguish 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?

It gives a concrete when-not rule: delete is unavailable for campaigns with accumulated statistics, and such a campaign can only be archived. That routing guidance is genuinely useful. It stops short of explaining when to reach for manage_campaigns versus update_campaign or list_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?

Annotations already declare destructiveHint=true and openWorldHint=true, so the destructive profile is covered. The description does not add anything beyond the enum, such as irreversibility detail (though the schema notes delete is irreversible) or bidding behavior on set_bids.

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 enumerating all supported actions. It is appropriately sized and front-loaded, with no filler, though it is not broken into structured when-to-use segments.

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 multi-action mutation tool with rich schema coverage and destructive annotations, the description is minimally viable. It lacks routing to sibling tools and does not clarify action-specific prerequisites, leaving modest gaps.

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

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

Schema coverage is 100%, so parameters are fully documented in the schema. The description adds no parameter detail beyond the action verb list, which matches the baseline 3 when the schema carries the load.

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

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

States a clear set of verbs (create, change bids, stop, resume, delete) applied to dynamic targets. It distinguishes itself from the sibling list_dynamic_targets by being the mutating counterpart, though it does not name that sibling explicitly.

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

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

The action list implies when each mode applies, but there is no explicit guidance on prerequisites or when to prefer this tool over siblings like list_dynamic_targets. Usage must be inferred from the enum values.

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 and readOnlyHint=false, so the safety profile is largely covered. The description adds the useful nuance that delete is irreversible, but it says nothing about auth requirements, whether suspend/resume can be undone, or side effects on bids or statistics.

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

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

A single front-loaded sentence that leads with the resource and the allowed actions, then flags the destructive one. No filler, no repetition beyond what is needed.

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, no-output-schema mutation tool, the definition is minimally adequate: safety is partly carried by annotations and the delete warning, but scope (per-keyword vs bulk behavior), reversibility of suspend/resume, and any limits on keyword_ids 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 action enum and irreversibility already documented in the schema itself. The description merely restates the same action set and the 'необратимо' note, adding no format, ordering, or batching semantics for keyword_ids.

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 (keywords/фразы) and enumerates the three concrete operations (suspend/resume/delete), so an agent knows it mutates existing keywords rather than adding or bidding on them. However, it never differentiates itself from close siblings like update_keywords, add_keywords, or set_keyword_bids, leaving the boundary implicit.

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

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

It lists what the tool can do but gives no when-to-use guidance, prerequisites, or routing to alternatives such as update_keywords or delete_ad_groups. The agent must infer from the action enum alone which sibling to pick for a given intent.

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. The description only restates the create/change/delete operations and adds no extra behavioral context such as irreversibility, overwrite semantics, authorization requirements, or side effects.

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 single sentence is efficient and front-loads the three supported actions. It wastes no words, though it is too terse to provide any action-specific structure.

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 multi-action mutation with no output schema, the annotations cover destructive behavior and the schema covers parameters and conditional requirements. The description is minimally adequate but omits action-dependent workflow context and return expectations, leaving some gaps for the agent to infer.

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

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

Schema description coverage is 100%, and the schema already documents the action enum, conditional required fields, ID constraints, and overwrite behavior. The description adds no parameter meaning beyond what the structured schema provides, so the baseline of 3 applies.

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

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

States concrete actions (create, modify, delete) and the resource (account-level shared negative keyword sets). It is clear what the tool does, but it does not explicitly distinguish itself from siblings such as list_negative_keyword_shared_sets or link_negative_keyword_sets.

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

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

The description gives no when-to-use or when-not-to-use guidance. The action enum in the schema indicates supported operations, but the description does not explain when this tool should be chosen over the list or link siblings.

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

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

Annotations already declare readOnlyHint=false, openWorldHint=true, and idempotentHint=true, so the safety/mutation profile is covered structurally. The description adds nothing on top: it does not say whether already-moderated ads are re-submitted, what status results, whether there is a review delay, or any account-level constraints.

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

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

A single short sentence with no filler, which is structurally clean, but it is under-specified rather than concise — every word restates what the name already conveys.

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/submission tool with no output schema, the description should at minimum explain what happens after submission and any constraints (e.g., the 1–10000 ad_ids limit is only in the schema). As written, an agent has no behavioral context about the moderation workflow.

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?

Only one parameter (ad_ids), and schema description coverage is 100% with item-level and array-level descriptions plus min/maxItems constraints. The description adds no format or batching detail beyond the schema, so the baseline 3 applies.

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

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

The description ('Send selected ads for moderation') is essentially a verbatim translation of the title ('Отправить объявления на модерацию'), adding no information beyond the name/title. It states a verb+resource, but does nothing to distinguish this tool from siblings like update_text_ad or manage_ads, and never explains what 'moderation' entails.

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

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

There is no guidance on when to use this tool versus alternatives such as update_text_ad or manage_ads, no prerequisites, and no mention of what state the ads must be in first. Usage must be entirely inferred from the name.

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

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

Annotations already declare destructiveHint=true and readOnlyHint=false, but the description adds the concrete consequences: replace discards prior phrases, an empty array clears the list, and add/remove read the current list themselves (an extra API call). This discloses what gets destroyed and the side-effect cost beyond what annotations provide.

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

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

Three sentences, front-loaded with the resource and the mandatory mode, and the most important gotcha (add vs replace) lands last. Some mode detail overlaps with the schema, costing a little density, but there is no filler.

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

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

For a 3-param mutation tool with no output schema, the description covers the essential behaviors: mode requirement, destruction semantics, and the read-then-write behavior of add/remove. It omits permissions/authorization context but is otherwise sufficient to call the tool correctly.

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

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

Schema description coverage is 100% and the mode field's schema already documents replace/add/remove semantics plus the matching/comparison rules. The description mostly reiterates the mode behavior and only adds the 'no need to read the list first' note, so it does not substantially extend the schema. Baseline 3 is appropriate.

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

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

States a specific verb and resource ('Минус-фразы на уровне группы объявлений') and pins the scope to ad-group level, which distinguishes it from the campaign-level siblings get_campaign_negative_keywords and set_campaign_negative_keywords. An agent can tell what this does 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 clear operational guidance: mode is mandatory, each mode's effect is spelled out, and it warns that to append you must use add rather than replace (with the concrete failure mode). It does not explicitly contrast the tool against the campaign-level sibling, so tool selection 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 declare readOnlyHint=false, destructiveHint=true, and openWorldHint=true, so the agent already knows this is a mutating, destructive, external-facing tool. The schema description for the 'delete' action notes it is irreversible ('необратимо'), which adds useful context beyond annotations. However, the description itself says nothing about permissions, rate limits, or side effects — it merely restates the action set.

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 efficient sentence listing the allowed actions. It is front-loaded and wastes no words, though it is extremely terse and arguably could not be shorter without losing the action enumeration.

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 destructive and open-world annotations, no output schema, and complex conditional parameter requirements (bids vs targets vs audience_target_ids depending on action), the description is almost absent. It does not explain action-parameter relationships, does not mention that some actions are irreversible beyond the schema note, and provides no behavioral context for a potentially high-impact operation.

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

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

Schema description coverage is 100%. Every parameter, nested field, and enum is fully documented in the schema, including when each array is required (add requires targets; set_bids requires bids). The one-sentence description adds no parameter meaning. Baseline 3 is appropriate when the schema does all the work.

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

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

The description states specific verbs (add, suspend, resume, delete, change bids) and the resource (аудиторные цели / audience targets). It clearly identifies the tool's operations, but does not differentiate it from base targeting — a reasonable inference is that this is a CRUD/bid-set tool for audience targeting. Sibling list_audience_targets is the read counterpart; no explicit disambiguation is needed but the description doesn't name 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?

The description implies when to use the tool (when you need to modify audience targets) but gives no explicit when-not or alternatives. The action enum in the schema effectively lists the operations, but the description adds no routing guidance beyond what the parameter already conveys.

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 idempotentHint=true, so the safety profile is covered. The description adds only the nuance that this changes coefficients of existing entries (a partial-update semantic rather than a full overwrite), and says nothing about scope limits, permissions, or what happens to unspecified fields.

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

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

A single short sentence with the action front-loaded; nothing is padded or redundant. It is efficient, though its brevity comes partly from omitting useful context rather than from tight 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?

The schema fully documents the single nested-array parameter and the annotations cover the mutation/idempotency profile, so an agent has enough to call this correctly. Only a note about batch size (max 1000) or prerequisites would be needed for a 5, but those are already in the schema bounds.

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% — the nested bid_modifier (0–1300, 100 = unchanged) and adjustment_id pattern are fully documented in the schema. The description echoes this with 'коэффициенты' and 'по их ID' but adds no syntax or format detail beyond the schema, so baseline 3 applies.

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

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

States a specific verb (Изменить) and resource (коэффициенты существующих корректировок), and 'существующих' hints it operates on already-created items rather than adding new ones. It does not, however, explicitly contrast itself with add_bid_adjustments or delete_bid_adjustments, leaving sibling differentiation to the reader.

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

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

The word 'существующих' and 'по их ID' imply this is for updating already-existing adjustments, which weakly implies add_bid_adjustments is the tool for new ones. No explicit when-to-use, when-not-to-use, or prerequisite (e.g. that IDs must be fetched via get_bid_adjustments) is given.

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

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

Annotations already declare destructiveHint=true and readOnlyHint=false, yet the description adds precise destruction semantics (previous phrases are lost, empty array clears the list) and a hidden cost (add/remove perform an extra read/API call). This is exactly the kind of context annotations cannot convey.

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

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

Front-loaded with scope, then mode semantics, then the key pitfall. Three sentences, zero filler, each earning its place.

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

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

For a destructive, three-required-parameter mutation with no output schema, the description covers mode behavior, side effects, and the read-before-write implication. Nothing an agent needs to invoke it 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?

Schema description coverage is 100% and the enum is fully documented in the schema, so the schema carries the baseline. The description still reinforces the mode contract and adds a practical warning about replace collaterally deleting other phrases, adding value beyond the schema.

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

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

States a specific operation (setting negative keywords) at a specific scope (campaign level), which cleanly distinguishes it from get_campaign_negative_keywords (read) and set_ad_group_negative_keywords (ad-group scope) among the siblings. An agent can identify the right tool 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?

Explicitly enumerates when to use each mode: replace for a full swap, add to append, remove to delete named phrases. It also gives a concrete decision rule ('to add a phrase to existing ones, use add — replace with one phrase erases the rest') and states the prerequisite is unnecessary ('no need to read the list first').

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

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

Annotations already cover readOnly=false, openWorld=true, idempotent=true, so the safety profile is known. The description adds genuinely non-structured context: the silent no-op on autostrategies and the mandatory prerequisite call ordering. It does not describe what happens with conflicting or multiple ID arrays, keeping it below 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?

Three sentences, front-loaded with the operation and scope, then preconditions, then the recommended call sequence. Dense and largely waste-free, though the middle sentence packs condition and consequence into a single long clause.

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

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

No output schema, so the description needn't explain returns, and annotations cover the mutation profile. However, all five parameters are optional and the description never states that at least one target level must be supplied, nor whether the target arrays are mutually exclusive — a real gap for a bid-setting tool with no required parameters.

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

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

Schema description coverage is 100% and every parameter (bid, context_bid, keyword_ids, ad_group_ids, campaign_ids) is documented in-schema with units and level meaning. The description repeats the per-ruble and per-level semantics without adding format or cardinality rules beyond the schema. Baseline 3 applies.

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

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

States a specific verb+resource (set bids, in rubles, for search/networks) and enumerates the three target levels: keywords, ad groups, campaigns. An agent can distinguish it from get_bid_adjustments or set_bid_adjustments. It does not explicitly name a sibling, so it stops short of a 5.

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

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

Explicitly states the precondition that makes this tool effective (manual bid management only) and the failure mode on autostrategies (call succeeds silently, no effect on impressions), plus a required workflow: get_strategy first, then get_keyword_auction. This is exactly the when/when-not guidance 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 readOnlyHint=false, destructiveHint=true, openWorldHint=true. The description adds valuable non-obvious context: that changing goals restarts strategy training (a destructive side effect) and that the server reads the current list itself (an extra API call). It doesn't detail auth requirements or rate limits, but adds meaningful behavioral context 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?

Front-loads the core purpose, then mode explanation, then warnings. Every sentence carries information, though slightly dense. Uses a warning symbol to draw attention to the training restart.

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 3-parameter mutation tool with no output schema and rich annotations, the description covers purpose, modes, supported campaigns, goal ID source, destructive side effect, and the server reading current list. It doesn't explain what happens to goals not mentioned in add vs remove modes beyond the mode descriptions, but is largely complete.

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

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

Schema description coverage is 100%, so baseline is 3. The description reinforces mode semantics and states value is in roubles and required for goals, plus mentions GoalId 13 for maximum conversions. The schema handles specific parameter details; description adds the 'why' and edge cases like empty array clearing.

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 (set strategy PriorityGoals) with their rouble value, and explains the optimization purpose including the auto-strategy context. Distinguishes itself from sibling set_strategy by focusing specifically on campaign goals, not general strategy settings.

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 explains when to use each mode: add to add/change value of existing goals, remove to remove named goals, replace to replace the entire list. Includes a critical warning that replace with one goal erases the rest, guiding correct usage. Names which campaigns are supported.

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 (a mutation) and openWorldHint=true, so safety profile is covered. The description adds one genuinely useful behavioral fact — that it returns a set ID for ad linking — but says nothing about permissions, duplicate handling, whether existing sets are overwritten, or side effects.

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 scope, followed by the return value. No filler or redundant clauses.

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 mutation tool with full schema coverage and annotations, the description is nearly complete and even compensates for the missing output schema by stating the returned ID. Only deeper mutation semantics (idempotency, overwrite behavior) are absent.

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

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

Schema description coverage is 100% and the nested items are fully documented (title 30 chars, description 60 chars, href), so the schema carries the parameter burden. The description's '1–8' range merely restates the minItems/maxItems already in the schema, adding no new 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 ('Создать новый набор из 1–8 быстрых ссылок'), which disambiguates the ambiguous 'set_' prefix as a create operation rather than a bulk-set. It does not explicitly contrast with siblings such as list_sitelinks or delete_sitelinks, 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?

Usage is only implied: the description notes the returned ID is meant for attaching to an ad, which hints at the workflow (create set, then link to ad). There is no explicit when-to-use, when-not-to-use, or named alternative among the sibling tools.

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