Growomat

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

Beyond the readOnlyHint annotation, the description discloses that it is backed by parallel SDK calls, clarifies the meaning of token.scheduling.timezones, and explains how last_sync indicates whether campaigns are live. It also states the Space-scoping behavior and the override semantics, adding significant 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?

The description is front-loaded with the core purpose, followed by details on output components and Space scoping. It is somewhat longer than strictly necessary, but each sentence adds essential context, so it remains efficient and well-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?

Given no output schema, the description enumerates the key sections of the returned document (token info, Spaces, campaigns, counts, stats, last_sync) and explains the scoping behavior. This makes it sufficiently complete for understanding the tool's output and usage without needing external references.

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

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

The single parameter space_id is already fully described in the schema with 100% coverage, including its purpose, default behavior, and effect on session binding. The tool description reinforces this but does not add new meaning beyond the schema, so the baseline 3 is appropriate.

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

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

The description clearly states the tool returns a single JSON account summary with specific components (token info, Spaces, campaigns, counts, stats, last_sync). It gives the tool a distinct purpose among siblings, emphasizing it as the cheapest way to get an account overview.

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 recommends using this before deciding what else to do, framing it as a discovery/overview tool. It also provides clear guidance on Space scoping: how to switch via set_active_space or override with space_id, and notes that branches are Space-scoped.

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

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

Annotations already indicate readOnlyHint=false and destructiveHint=false. The description adds useful behavioral context: campaignId is derived when omitted, the tool returns the full updated/created object, and space scoping behavior. No contradictions detected.

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

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

The description is front-loaded with the core purpose and contains no filler. However, it repeats the full role enum which is already in the schema, slightly adding length without new information. Still, it remains efficient and well-organized.

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

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

Given the tool's moderate complexity and lack of an output schema, the description covers essential information: return value, scope rules, ID derivation, and space scoping. It does not cover error cases or edge behaviors, but those are beyond the typical expectation for this context.

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

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

The schema has 100% top-level coverage, but the description goes beyond by explaining the conditional requirement of adId vs adGroupId based on scope, listing all role values, and clarifying that campaignId can be omitted. It also explains the space_id override parameter's effect, providing semantics not in the schema.

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

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

The description clearly states the tool's function: attaching an existing asset to an ad or ad group with a specific role. It distinguishes itself from sibling tools like attach_asset_to_campaign by explicitly mentioning the AD/AD_GROUP scope and noting this is the scope that actually serves images/video.

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

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

Provides clear guidance on when to use AD vs AD_GROUP scope and explains the practical relevance ('actually serves images/video on Display, Performance Max and Video campaigns'). It also notes campaignId derivation and active Space handling, giving clear context for invocation. Does not explicitly name a sibling alternative but the distinction is implied.

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

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

Annotations indicate readOnlyHint=false and destructiveHint=false, so the write nature is implied but the description adds that it returns the full updated/created object and describes Space scoping behavior. This goes beyond the annotations by clarifying the return value and override option.

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 succinct sentences cover the action, role examples, return value, and Space scoping, with zero redundancy. Every clause provides useful information.

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

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

Given no output schema, the description compensates by stating the return type ('full updated/created object'). Space scoping is clearly explained. Nested objects are acknowledged with a pointer to the OpenAPI spec, which is acceptable since the most important behavioral and scoping details are covered.

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

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

The schema provides enum values for role and a pattern for space_id, but the description enhances understanding by giving concrete role examples and explaining that space_id overrides the active Space for one call. The body schema says to see OpenAPI spec for nested shapes, which is reasonable since the core fields are already named.

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

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

The description uses a specific verb ('attach') with a clear resource ('asset to a campaign') and adds role examples (MARKETING_IMAGE, LOGO). It differentiates from siblings like attach_asset_to_ad and detach_asset_from_campaign via the explicit 'campaign' scope.

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

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

The description states the tool is scoped to the active Space and directs users to set_active_space or pass space_id to override, providing clear context for when to use this versus other space-related tools. It doesn't explicitly mention alternatives like attach_asset_to_ad, but the naming makes the campaign vs ad distinction obvious.

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 provide readOnlyHint=false and destructiveHint=false, which already signal mutation and potential impact. The description adds valuable behavioral context: cancellation is not immediate (next campaign boundary), already-pushed campaigns are not rolled back, and it's scoped to the active Space. This goes beyond annotations but could mention what happens to the sync status or if cancellation can fail, so a 4 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 sentences, front-loaded with the primary action, followed by critical behavioral notes and scoping clarification. Every sentence earns its place—no filler or redundancy.

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

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

Given the tool's complexity (mutation with scoping behavior), the description covers the key aspects: how cancellation works, what it does not do (rollback), and how Space scoping is handled. It lacks an explicit return value description, but there is no output schema and the sync status can be verified via get_sync_status, so the description is largely complete. A 4 rather than 5 because it doesn't mention prerequisites like having a sync actively running or any error conditions.

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

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

Schema coverage is 50%: sync_id has no description in the schema, but the description clarifies that it targets a running sync. space_id has a detailed schema description, and the tool description reinforces how it overrides the active Space. The description adds meaning for sync_id beyond the schema, so it compensates for the coverage gap.

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

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

The description clearly states the verb ('Request cancellation') and resource ('a running sync'), and distinguishes this from sibling tools like trigger_sync and get_sync_status. It also specifies the cancellation is scoped to the active Space, which differentiates it from other sync-related 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 explicitly explains when to use this tool versus alternatives: it mentions canceling a running sync, that it takes effect at the next campaign boundary, and that it's scoped to the active Space with a note to use set_active_space to switch or pass space_id to override. This provides clear context and 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 indicate readOnlyHint=false and destructiveHint=false, so the agent knows this is a mutating but non-destructive operation. The description adds useful behavioral context beyond annotations: it states the return value ('Returns the full updated/created object') and the Space scoping behavior, which are not specified in annotations. No contradiction 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?

The description is two sentences, front-loaded with the purpose, then the return value and Space scoping. Every sentence earns its place, with no redundant or vague wording.

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

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

The tool has a complex body schema and no output schema; the description covers the key contextual elements: what the tool does, what it returns, and how Space scoping works. It appropriately leaves field-level details to the schema. Slight gaps remain, such as not mentioning that the ad group and campaign must already exist, but those are implied by the required fields and are not explicitly stated elsewhere.

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

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

Schema description coverage is 100%, so the baseline is 3. The description does not add significant parameter details beyond the schema: the space_id override behavior is already fully described in the schema, and the body's structure is referenced via 'Request body matching the AdCreate schema.' The description adds little new information about parameters.

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

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

The description states 'Create a new ad inside an ad group' with a specific verb and resource, and clearly distinguishes it from sibling tools like create_ad_group (which creates a group) and update_ad (which modifies an existing ad). The scope 'inside an ad group' adds further precision.

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

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

The description gives clear usage context for Space scoping: 'Scoped to the active Space — see set_active_space to switch, or pass space_id to override for this one call.' This tells the agent how to control the Space context, but it does not explicitly state when to use this tool over alternatives or when not to use it, so it falls short of a 5.

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

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

Annotations already indicate this is a write operation (readOnlyHint=false) and not destructive (destructiveHint=false). The description adds behavior beyond annotations by stating it returns the full object and that it's scoped to the active Space, with a per-call override option.

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 that are front-loaded with the core purpose and followed by scoping guidance. Every word earns its place; no filler or repetition.

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

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

For a create tool with nested objects and no output schema, the description covers the key aspects: the operation, the return value, and the space-scoping behavior. It relies on the rich schema for parameter details, which is appropriate given 100% schema coverage.

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 descriptions for body (including required fields and nested object references) and space_id. The tool description adds no parameter-specific detail beyond what the schema already documents, so 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 starts with 'Create a new ad group under a campaign' — a specific verb, resource, and scope. It clearly distinguishes from update/delete/list siblings and other create_* tools.

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

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

The description provides clear context on when to use it: it requires a campaign and is scoped to the active Space. It also gives alternative usage instructions (set_active_space or pass space_id), though it doesn't explicitly state when not to use it.

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

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

The description adds meaningful non-obvious behavior by explaining that the operation is scoped to the active Space and can be overridden with space_id. It also explains that angleType is not arbitrary but a registry id from a vocabulary tool, which goes beyond the annotations.

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

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

The description is compact and front-loaded: purpose, vocabulary requirement, and Space-scoping behavior are all stated in three efficient sentences with 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?

An agent gets enough to construct a valid request: the business scoping, the angleType source, and the Space-handling semantics. A small gap is not saying what happens on invalid or duplicate data, but that is not essential for basic 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?

The schema includes both top-level parameters, but the description adds real semantics for body.angleType — it must come from get_creative_vocabulary. It also clarifies businessId as the business scope and reinforces the meaning of space_id.

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 defines a specific verb and resource — create an angle — and explains what an angle is: 'a claim a set of ads argues, scoped to one business.' This distinguishes it from other create_* tools like create_concept or create_asset.

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

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

It provides clear prerequisites and setup context: angleType must come from a registry via get_creative_vocabulary, and the call is scoped to the active Space. It does not explicitly list when not to use this tool, but the definition is specific enough for basic selection.

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

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

Annotations only indicate readOnlyHint=false and destructiveHint=false, so the description carries the burden. It discloses that the tool stores a URL reference and lazily fetches bytes on sync, returns the full object, and respects space scoping. This gives meaningful behavioral context beyond the basic mutation hint.

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 main action. Every sentence adds value—purpose, behavioral detail, and scoping—without redundancy.

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

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

The tool has a complex nested body and no output schema, but the description covers the key behaviors: space scoping, lazy fetch, and return value. It doesn't elaborate on nested metadata shapes, but the schema points to the OpenAPI spec, so the description is adequate for selection and basic 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 coverage is 100% with descriptions for body and space_id. The description adds minimal new detail about parameters, merely reinforcing that the asset is registered by URL and space_id can override. This matches the baseline 3 for high schema coverage.

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

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

The description clearly states the tool registers an asset by URL, lists supported types (image, logo, video), and distinguishes it from update/delete by noting lazy fetch behavior and space scoping. This is a specific verb+resource definition that differentiates it from sibling tools like update_asset or attach_asset_to_ad.

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

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

It provides clear context: scoped to active Space, with a pointer to set_active_space and space_id override. However, it doesn't explicitly state when to prefer this over update_asset or list exclusions, so it falls short of fully explicit alternatives.

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

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

Annotations give only readOnlyHint=false and destructiveHint=false. The description adds meaningful behavioral context: the brand object governs all generated ad and social copy, the operation is scoped to the active Space, and the full created object is returned. This goes beyond the annotations and helps the agent understand the side effects and scope.

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

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

Three sentences with no filler: first states the action and key fields, second clarifies the brand profile's significance, third covers return and Space scope. The structure is logical and front-loaded with the most important information.

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

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

The description covers the essential context needed for invocation: required and optional fields, the brand's cross-cutting effect, Space scoping, and the return type. It doesn't mention error handling or prerequisites, but for a create tool with a comprehensive schema, this is sufficient. The reference to the OpenAPI spec for nested shapes fills remaining 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 baseline is 3. The description adds semantic value for the brand parameter by explaining its role ('governs all generated ad and social copy') and listing its sub-fields (tone dials, voiceNotes, promises, bannedPhrases). For space_id, the description reinforces the schema's override semantics. This is a clear improvement over the structured schema alone.

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

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

The description opens with 'Register a new business' – a specific verb and resource that clearly distinguishes this from sibling tools like update_business or delete_business. It enumerates the core and optional fields (name, website, description, target groups, SEO keywords, sitelinks, brand profile) and states the return value, making the tool's function unmistakable.

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

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

The description clearly implies usage for creating a new business, and it provides concrete guidance on Space scoping: how to switch via set_active_space or override with space_id. However, it does not explicitly say 'use update_business to modify an existing business' or list exclusion criteria, so it falls short of the most explicit level.

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

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

Annotations already indicate this is not read-only and not destructive, so the base is safe. The description adds that it returns the full object and respects active Space/space_id override, which is useful behavioral context. However, it does not disclose potential side effects (e.g., costs, status implications) or error behavior, but overall it is adequate.

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

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

Two sentences deliver purpose, return value, and scoping guidance with zero waste. The structure is front-loaded and immediately informative.

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

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

Given no output schema and high complexity, the description covers the key invocation context: creation, return, Space scoping, and override. It doesn't detail output shape, but that is implicitly the created/updated object. The rich input schema handles nested field documentation, making the description sufficiently complete for selection and usage.

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 rich descriptions for all properties including nested objects, enums, and special constraints. The description adds no extra parameter semantics beyond what the schema already states (e.g., space_id override is also in 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?

The description clearly states 'Create a new campaign' with a specific verb and resource, and adds value by noting the returned object and Space scoping. It distinguishes itself from sibling tools like create_ad_group or update_campaign by explicitly naming the operation and key context.

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

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

The description provides clear context on Space scoping and references set_active_space and space_id override, guiding the agent on how to control which Space is affected. It does not explicitly state when not to use this tool or name alternative creation tools, but the scoping guidance is actionable.

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

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

Annotations already establish that this is a non-read-only write (readOnlyHint=false) and non-destructive (destructiveHint=false). The description adds genuine behavioral context: the mutation is bound to the current session's active Space, are not an explicit target, and attribute values depend on the creative vocabulary registry. No contradiction with the annotations; the description adds detail beyond the annotation baseline.

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 compact sentences, each earning its place: creation target, attribute-format dependency, and scoping mechanism. The scoping constraint is clearly packed into the sentence with the fallback tool named. No fluff, no repetition of schema content verbatim.

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

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

For a tool with a nested body and full schema coverage, the description covers the essential operational context: where the concept is created (under an angle), where attribute values come from, and how Space scope is resolved. The only meaningful gap is the absence of an output/response statement — but there is no output schema — and the assumption that the referenced angle must already exist is probabilistic. Overall it's complete enough for an agent to call it reasonably.

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

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

The schema already documents 100% of parameters (body and space_id, with types and patterns), so the baseline is 3. The description adds value beyond the schema by revealing that the array of attribute strings must be valid registry IDs from get_creative_vocabulary — something the body schema does not explain. It also clarifies the space_id override semantics at a higher level in combination with set_active_space.

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?

'Creates a concept under an angle' is a specific verb+resource+placement statement, so the agent can tell this apart from create_angle (creates the angle itself) and update_concept (modifies). The resource hierarchy (concept under angle) is explicit, which is the core signal an agent needs to select this tool. It doesn't name a sibling directly, but the verb+object combination is concrete enough to disambiguate.

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?

Provides clear operational guidance: it points to set_active_space for switching scoping and says space_id overrides the bound Space for one call — exactly what the agent needs to know before invoking. It also names a prerequisite source, get_creative_vocabulary, for attribute registry ids. It stops short of explicitly stating when an alternative (e.g., update_concept) should be preferred, but the selection context is clear.

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

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

Annotations already indicate a non-read-only, non-destructive operation. The description adds valuable behavioral context beyond annotations: the action is created locally and only gains a remote id and tag snippet through sync, and it is scoped to the active Space with an override option via space_id. This informs the agent about side effects and state, going beyond the basic mutation flags.

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

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

The description is three sentences, front-loaded with the primary purpose, and every sentence earns its place by explaining key concepts (local creation, sync, space scoping). There is no redundancy or fluff, making it highly concise and well-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?

Given the nested body object and no output schema, the description adequately explains the tool's role, local creation vs export, and space override behavior. It does not describe the return value, but this is not required since no output schema is present. The context provided is sufficient for correct tool invocation, though it could mention what happens on success (e.g., returns the newly created action) to be fully complete.

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

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

Schema coverage is 100%, so the schema already documents all parameters with descriptions. The description only repeats the requirement for body's minimum fields ('at least { name, type, category }') which is also present in the body description, and adds no unique parameter-level detail. Baseline 3 is appropriate because the schema handles the heavy lifting.

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

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

The description states a specific verb ('Create') and resource ('a conversion action'), defines it as 'the thing an uploaded conversion is counted against', and distinguishes it from sibling tools like create_conversion_source and upload_offline_conversion by explaining that creation is local and exporting happens through campaign sync. This makes the tool's purpose unambiguous and clearly differentiated.

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

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

The description gives clear workflow context: 'created locally' and 'exporting ... happens through campaign sync', indicating when to use this tool within a larger process. It also explains space scoping and points to set_active_space as an alternative for switching spaces. However, it does not explicitly state when not to use this tool versus other create_* tools, though the distinction is implied.

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

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

Beyond the readOnlyHint=false annotation, the description reveals idempotency per type by default and the scoping behavior, adding meaningful behavioral context. It does not mention auth or rate limits, but the disclosed traits materially help an agent predict 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 sentences with no fluff: the first states purpose, the second prescribes the body shape, and the third covers idempotency and scoping. Each sentence carries essential information.

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

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

Given the moderate complexity (nested body, space scoping, idempotency), the description covers the main behavioral and payload aspects. It lacks explicit error/response details, but the absence of an output schema makes that less critical. Overall, it is sufficient for correct invocation.

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

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

The schema provides basic field descriptions, but the tool description goes further by enumerating the concrete type values (stripe|webhook|hubspot|salesforce|ga4), clarifying config/accountRef as optional, and explaining the space_id override semantics. This substantially augments the schema information.

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

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

The description clearly states the action 'Connect a revenue/conversion source to the active Space' and explains its purpose (feeds measured conversions back to ad platforms). This distinguishes it from sibling tools like create_conversion_action, which target conversion actions rather than sources.

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

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

The description provides clear context on scoping: it mentions the active Space, the set_active_space sibling tool for switching, and the space_id override for one call. However, it does not explicitly list alternative tools or when-not-to-use conditions, so it lacks explicit 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 indicate a non-read-only, non-destructive operation, and the description aligns by stating 'Add' and 'Returns the full updated/created object.' It adds behavioral detail about scoping and return value, which goes beyond the annotation flags.

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

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

The description is two sentences long, front-loaded with the core action, and contains no wasted words. Every clause contributes to understanding the tool's purpose and usage.

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

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

For a write tool with a nested body schema and no output schema, the description covers the key return behavior ('Returns the full updated/created object') and scoping. It does not detail nested object shapes, but the schema compensates, and the description is sufficient for 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 coverage is 100%, so the baseline is 3. The description adds value by explaining the space_id override behavior ('pass space_id to override for this one call'), which reinforces the schema's description and provides context not immediately obvious from the parameter list.

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

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

The description clearly states 'Add a keyword to an ad group,' which is a specific verb and resource. It distinguishes from sibling tools like delete_keyword, update_keyword, and list_keywords, and mentions the returned object, leaving no ambiguity.

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

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

The description gives clear context about the active Space scope and how to override it with space_id, referencing set_active_space. It does not explicitly contrast with alternatives like update_keyword, but the usage context is well-defined.

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

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

The description adds meaningful context beyond annotations: it states 'Permanently deletes the resource. Irreversible.' and explains the Space scoping behavior. The annotations already mark destructiveHint=true, so the description's value is in reinforcing the permanence and providing the scoping detail.

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 tightly written: three short sentences that each carry essential information. No filler, and the most important fact (permanent deletion) is front-loaded.

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

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

For a simple deletion tool with annotations and only two parameters, the description fully covers purpose, risk, and the active-Space behavior. There is no output schema expected, so no missing return information. The description is sufficient to invoke 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?

The schema already provides a detailed description for space_id, and the description reinforces its behavior and default. However, ad_id has no description in the schema and the description doesn't clarify its format or requirements beyond being required. With 50% schema coverage, the description partially compensates but could go further.

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

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

The description begins with a specific verb and resource ('Delete an ad'), clearly distinguishing it from sibling tools like delete_ad_group or delete_campaign. It also states the scope and the permanent nature, removing ambiguity.

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

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

The description clearly ties usage to the active Space, explicitly telling the user how to switch (set_active_space) or override per-call (space_id). This is helpful context, though it doesn't explicitly mention when not to use the 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?

Beyond the annotations (destructiveHint=true, readOnlyHint=false), the description discloses critical behavioral traits: the 409 failure on dependent resources, cascade behavior, permanent and irreversible deletion, and active Space scoping. This adds significant context that annotations alone do not 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 three sentences, each adding essential information: the core action, the cascade-caused 409 behavior, and the permanence/scoping context. There is no redundancy or filler, and the main action is front-loaded.

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

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

For a deletion tool with no output schema, the description covers all critical operational aspects: dependent-resource handling with cascade, irreversibility, and Space scoping. It is complete enough for agents to use safely and correctly without additional external knowledge.

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

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

The description enhances schema parameter meaning by explaining that cascade=true deletes dependents in the same request, and space_id overrides the active Space for one call. It also implies ad_group_id as the target resource from the purpose, compensating for the schema's missing description for that parameter.

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

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

The description uses the specific verb 'Delete' and clearly identifies the resource as 'ad group', distinguishing it from sibling delete tools for other resources. It also states the primary behavior outright without ambiguity.

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

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

It explicitly explains when to use the cascade parameter (to delete dependent ads/keywords in the same request) and the default 409 behavior when dependents exist. It also names set_active_space as an alternative for switching spaces and offers space_id as an override, providing clear context and alternatives.

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

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

Even though annotations already mark destructiveHint=true, the description goes beyond that by disclosing the cascade deletion of concepts and the unusual side effect that ads retain a dangling-but-queryable stamp. It also explains Space scoping behavior and the override mechanism, which annotations do not cover.

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

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

Three sentences pack in the core action, destructive consequences, side effects, and space-scoping rule without any fluff. The most important information is front-loaded, and every sentence carries meaningful guidance.

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

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

For a delete tool with no output schema, this description covers all critical context: what is deleted, what is affected, what persists, and how to target the right Space. An agent has enough information to safely invoke the tool and understand its consequences.

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

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

The schema covers space_id well with its own description, and the tool description reinforces the Space-scoping semantics. However, angle_id is undocumented in both the schema and the description, leaving the agent to infer its meaning from the parameter name alone. This is acceptable but leaves a small gap.

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

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

The description clearly states the action and resource: 'Delete an angle.' It also distinguishes itself from related angle tools by noting the cascade behavior ('concepts are deleted with it') and with a specific verb, so an agent can tell it apart from create_angle, update_angle, and get_angle.

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 explicit context for the Space scoping, telling the agent to see set_active_space to switch spaces or pass space_id to override for this call. It does not discuss when not to use the tool, but for a destructive delete this guidance is less critical.

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 include destructiveHint=true and readOnlyHint=false, but the description adds crucial behavioral details: 'Permanently deletes the resource. Irreversible.' This goes beyond the generic destructive flag by specifying permanence and irreversibility. It also clarifies Space scoping and override, adding significant context beyond the annotations. No contradiction.

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

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

The description is three sentences long, front-loaded with the primary action, then consequences, then scoping. Every sentence adds value with no redundancy or fluff. It is concise, well-structured, and highly readable.

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

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

Given the tool's simplicity (2 params, no output schema, no nested objects), the description adequately covers purpose, consequences, and space scoping. It does not mention return values or error conditions, but these are not critical for a straightforward deletion tool and are not required by the output schema. The description is complete enough for an agent to use the tool correctly.

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

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

Schema description coverage is 50% (only space_id has a description). The tool description mentions 'pass space_id to override' and 'set_active_space to switch', which reinforces the space_id parameter's semantics but does not add much beyond the schema's description. asset_id remains undocumented in both, though its meaning is clear from the tool name. The description partially compensates for the coverage gap but not fully.

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

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

The description clearly states the tool's function: 'Delete an asset. Permanently deletes the resource.' It uses a specific verb and resource, distinguishing it from other delete_* sibling tools. The addition of 'Irreversible' clarifies the destructive nature, making the purpose unambiguous.

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

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

The description provides clear context on how to scope the deletion ('Scoped to the active Space — see set_active_space to switch, or pass space_id to override for this one call'), which is important for correct usage. However, it does not explicitly mention when to use this tool over alternatives (e.g., other delete tools) or when not to use it, though the resource name makes this reasonably implicit.

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 destructiveHint=true, the description discloses the 409 failure on references, irreversibility, permanence, and Space scoping with override behavior. These are non-obvious behavioral traits that annotations alone don't capture, and there is no contradiction.

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

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

The description is two sentences, front-loaded with the core action and packed with essential constraints (409, no cascade, irreversible, scope). Every sentence earns its place with 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 destructive delete tool with 2 params and no output schema, it covers prerequisites, error handling, permanence, and scope override. The only potential missing item is auth/permissions, but that's not expected given no annotations mention it and the constraints are thorough.

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 covers space_id with a detailed description, but business_id has no description in the schema. The description only restates the space_id override concept and doesn't add new meaning for business_id. With 50% schema coverage, it meets the baseline but doesn't add 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?

Starts with 'Delete a business' — a specific verb+resource. Distinguishes from sibling delete_* tools by mentioning the campaign-reference constraint and Space scoping, making it clear this targets business entities only.

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?

Provides a clear precondition: campaigns referencing the business must be deleted/reassigned first, and notes no cascade is offered. Explains Space scoping with a pointer to set_active_space. Does not explicitly mention an alternative like update_business for non-destructive changes, so it's not a full 5.

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

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

While annotations already mark this as destructive, the description adds 'Permanently deletes the resource. Irreversible.' which reinforces the finality. It also reveals that the operation is scoped to the active Space, a behavioral trait not present in annotations.

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

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

Two sentences, front-loaded with the core action, and every word adds value. No filler or repetition.

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

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

For a simple delete operation with two parameters and no output schema, the description covers permanence, irreversibility, and space scoping adequately. It doesn't cover error cases or side effects, but for a low-complexity destructive tool, this is sufficient.

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

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

Schema coverage is only 50% (space_id has a description, campaign_id does not). The description adds context for space_id by explaining when to use the override, but campaign_id semantics are left implicit. The tool name and purpose make campaign_id obvious, but the description doesn't explicitly clarify its format or requirements.

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 starts with 'Delete a campaign' which is a specific verb+resource pair, clearly distinguishing it from other delete tools for ads, assets, etc. It also clarifies the scope of deletion, making the purpose unambiguous.

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

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

The description provides clear context on how to control the target resource via Space scoping, mentioning set_active_space and the space_id override. It doesn't explicitly name alternatives, but the Space guidance is helpful for correct usage.

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 readOnly=false, and the description does not contradict that. It adds useful non-obvious behavior beyond annotations: deleted concepts leave ads' stamps intact, and the operation respects the active Space or can be overridden for a single call.

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

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

The description is short, front-loaded with the main action, and every sentence earns its place. It states what happens, the side effect, and the relevant scoping behavior without bloat.

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

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

Given the destructive annotation, simple two-parameter schema, and absence of an output schema, the description provides enough context for correct invocation: it names the action, the side effect, the Space scoping, and the override mechanism. The only minor gap is no explicit format or semantics for concept_id, but the tool name makes it clear.

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

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

Schema description coverage is 50%, so the schema fully documents only space_id. The description reinforces the space_id override behavior but does not add much meaning for concept_id, though that parameter is self-evident from the tool name and is the required identifier.

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: 'Delete a concept.' This cleanly distinguishes it from other delete_* siblings in the tool list, and the side-effect note ('Ads keep their stamp') adds domain-specific clarity about what the deletion does not affect.

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

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

It clearly conveys the operative context: the operation is scoped to the active Space and tells the agent how to change or override that Space via set_active_space or space_id. It does not explicitly list when not to use this tool versus other delete_* tools, but the resource 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 mark destructiveHint=true, but the description adds significant detail: 'Permanently deletes the resource. Irreversible.' It also discloses the conflict behavior (refuses and names campaigns) and the force override, plus Space scoping behavior. This goes far beyond annotation basics.

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 primary action. Each sentence adds distinct value: irreversibility, conflict handling, and scope override. No redundant or filler content.

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

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

For a destructive tool with no output schema, the description covers all critical aspects: what is deleted, irreversibility, failure conditions, override mechanism, and space scoping. It is complete for the tool's complexity.

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

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

Schema coverage is 67% (conversion_action_id lacks description). The description explains force ('Pass force to delete anyway') and space_id ('pass space_id to override for this one call') in meaningful context. conversion_action_id is left implicit, but it is the required resource identifier and is obvious from the tool name.

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

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

The description opens with a specific verb+resource: 'Delete a conversion action.' It clearly distinguishes this from sibling tools like create_conversion_action, update_conversion_action, and get/list_conversion_action. It also adds irreversibility, making the purpose unmistakable.

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

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

The description provides clear context on when to use this tool (to permanently delete a conversion action) and explains the conflict scenario when campaigns bid on the action. It mentions set_active_space as an alternative for scope switching, but does not explicitly name alternate tools for deletion or when not to use. Still, the usage context is strong.

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 set destructiveHint=true and readOnlyHint=false, but the description adds 'Irreversible' and 'Permanently deletes the resource,' clarifying the consequences. It also discloses the space scoping behavior, which is not in annotations.

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

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

The description is three short sentences, front-loaded with the action and consequences, followed by scoping details. Every sentence adds value without redundancy.

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

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

For a simple delete operation with two parameters, the description covers purpose, irreversibility, and space scoping. It omits return values or error handling, but given the absence of an output schema and the tool's simplicity, this is acceptable. The destructive annotation plus the irreversibility warning provide a complete safety profile.

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

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

The schema covers space_id with a description, and the description reinforces its use for overriding the active Space. However, keyword_id has no schema description beyond its name, and the description does not elaborate on it, leaving a gap for the required 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 clearly states 'Delete a keyword' and emphasizes 'Permanently deletes the resource.' This uses a specific verb and resource, distinguishing it from sibling delete tools like delete_ad and delete_campaign.

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

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

The description provides explicit scoping guidance: 'Scoped to the active Space — see set_active_space to switch, or pass space_id to override for this one call.' This tells the agent how to target the correct space and when to use set_active_space vs the space_id parameter, which is practical guidance beyond just identifying the tool.

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

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

The description claims the operation is 'Permanently deletes the resource' and 'Irreversible', but the annotations declare destructiveHint=false. This is a direct contradiction (Annotation Contradiction). The description's behavioral transparency is undermined because the structured metadata disagrees; no credit can be given for disclosure when it conflicts with annotations.

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

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

The description is two concise sentences, front-loaded with the core action and followed by essential caveats about permanence and scoping. Every clause adds value without redundancy. Well-structured and easy to parse.

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

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

The description covers purpose, scoping, and irreversibility, but there are notable gaps: no mention of return value or side effects beyond deletion, no prerequisites (e.g., asset must be attached), and the ambiguity of 'deletes the resource' remains unresolved. With no output schema and contradictory annotations, the description should be more complete.

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

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

The schema covers space_id with a detailed description, which is reflected in the description's mention of the override behavior. However, ad_asset_id (the required parameter) is not described in the schema or the description, and schema coverage is only 50%. The description adds some value by explaining the space scoping, but does not compensate for the missing ad_asset_id semantics.

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

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

The description clearly states the action: 'Detach an asset from an ad / ad group' and distinguishes it from sibling tools like detach_asset_from_campaign. However, the clause 'Permanently deletes the resource' is ambiguous—it could refer to the association or the asset itself, which slightly clouds the purpose.

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

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

The description provides useful scoping guidance: it mentions the active Space, points to set_active_space for switching, and notes that space_id can override for a single call. It does not explicitly contrast with detach_asset_from_campaign or state when to use this over other detachment tools, so it falls short of a 5.

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

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

The description states 'Permanently deletes the resource. Irreversible.', while annotations set destructiveHint=false and readOnlyHint=false. This is a direct contradiction: the description clearly indicates a destructive, irreversible action, but the annotations suggest it is not destructive. This is a serious inconsistency.

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 relatively short but includes redundant and contradictory phrases like 'Permanently deletes the resource. Irreversible.' These do not add value beyond the core purpose and could confuse users. The structure is front-loaded with the main action but then detracts with misleading details.

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

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

The tool has no output schema, and the description does not explain return values or error behavior. The destructive nature is contradicted by annotations, and the required parameter campaign_asset_id is not described. While the Space scoping info is useful, the overall description is incomplete for a mutation tool with these 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?

The description mentions space_id, adding context about overriding the active Space, which complements the schema's description. However, the required campaign_asset_id parameter has no description in either the schema or the tool description, and its meaning is only implied by the tool name. Schema coverage is 50%, and the description only partially compensates.

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

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

The description clearly states the action 'Detach an asset from a campaign', distinguishing it from the sibling tool detach_asset_from_ad. However, the follow-up 'Permanently deletes the resource. Irreversible.' introduces ambiguity about whether the asset itself or the association is deleted, which could mislead.

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

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

The description provides context about Space scoping and how to override it via space_id, referencing set_active_space. However, it does not mention when to use this tool versus detach_asset_from_ad or other alternatives, and lacks 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, so the description goes beyond by disclosing the source field values ('env', 'set_active_space', 'default'), the fallback to the caller's Personal Space, and the no-API-round-trip behavior when unbound. This is rich 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?

Three sentences with no fluff. The first sentence states the purpose, the second lists return fields and source values, and the third covers the no-round-trip edge case. Every sentence earns its place.

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

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

For a parameterless getter with no output schema, the description fully documents the return shape, source values, and the unbound fallback behavior. It is complete for an AI agent to invoke and interpret results correctly.

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

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

The tool has zero parameters, so the schema already covers 100% of parameter meaning. The description does not need to compensate, and the baseline of 4 applies. It does explain the return object, which is relevant to the tool's semantics.

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

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

The description clearly states the tool reports the MCP server's current active Space binding, with a specific verb+resource and a detailed return object. This distinguishes it from siblings like set_active_space and list_spaces.

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?

Clear context as a read-only getter for the active space, with source semantics explained. No explicit when-not or alternative mentioned, but the obvious counterpart is set_active_space, so the usage is implied.

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

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

Beyond the readOnlyHint annotation, the description discloses the important behavioral trait that the tool is scoped to the active Space and can be overridden via space_id. This adds meaningful context, though it does not describe return format or error handling.

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

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

The description is two sentences, front-loaded with the core action, and every word earns its place. No redundancy or filler.

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

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

For a simple single-resource fetch, the description covers the key scoping nuance and override mechanism. Without an output schema, it could mention what is returned, but the tool's behavior is straightforward enough that this is a minor gap.

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

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

The description clarifies that ad_id is the identifier used for fetching, but the schema already fully documents space_id (50% coverage). The description partially compensates for the missing ad_id documentation but does not add constraints or format details.

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

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

The description uses the specific verb 'Fetch' and identifies the resource as 'one ad by id', which clearly distinguishes it from list_ads or other get_* tools. It also mentions the Space scoping, a defining characteristic of this tool.

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

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

The description provides clear context on how the tool uses the active Space and explains the set_active_space and space_id override options. It does not explicitly mention alternative tools or when not to use it, but the purpose is self-evident for fetching a single ad by 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?

The description adds the important behavioral detail that the fetch is scoped to the active Space and can be overridden with space_id, which is beyond the readOnlyHint annotation. No contradiction with annotations.

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

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

Two concise sentences, with the main action stated first and then the scoping context. No fluff or redundant 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 simple get-by-id tool with no output schema, the description covers the essential functionality and the key space-scoping constraint. It omits return values or error cases, but those are less critical for a fetch 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?

The schema already thoroughly documents space_id, but ad_asset_id has no description in the schema. The description clarifies that the tool fetches 'by id', giving ad_asset_id a role, but does not add format or type details. With 50% schema coverage, the description provides only marginal extra meaning.

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

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

The description uses the specific verb 'Fetch' with the resource 'ad-asset binding' and identifies the id parameter, clearly distinguishing it from sibling tools like get_asset, get_ad, and list_ad_assets.

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

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

It provides explicit guidance on space scoping, telling the user to see set_active_space to switch or pass space_id to override. It does not explicitly mention alternatives to this tool, but the context is clear.

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

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

Annotations already declare readOnlyHint=true, so safety is covered. The description adds behavioral detail about Space scoping—how the active Space context works and how to override it via space_id—which is not encoded in the annotation. This is useful context beyond the structured data.

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

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

The description is a single sentence, front-loaded with the core action ('Fetch one ad group by id'), followed by scoping instruction. Every word earns its place, with no redundant or vague phrasing.

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 get tool, the description covers purpose, scoping, and override mechanism. No output schema exists, but the return value (the ad group) is implied by the name and description. It does not mention error behavior or not-found cases, but that is not critical for a basic read 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?

The schema describes space_id in detail (50% coverage), and the description adds that ad_group_id is the lookup key ('by id'). However, it does not add significant meaning beyond the schema; the space_id override is already well-documented in the schema. The description gives minimal extra parameter guidance for ad_group_id.

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

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

The description opens with 'Fetch one ad group by id,' clearly specifying the verb (fetch), resource (ad group), and granularity (one by id). This distinguishes it from list_ad_groups, which lists multiple ad groups, and from get_ad or get_campaign, which target different resources.

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

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

The description explicitly states scoping to the active Space, points to set_active_space to switch, and mentions the space_id override for a single call. This gives clear usage context and names an alternative tool for changing scope, though it does not explicitly contrast with list_ad_groups or state when not to use this tool.

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

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

The annotations already declare readOnlyHint=true. The description adds useful behavioral context beyond that: it is scoped to the active Space, the Space can be overridden per-call, and set_active_space changes that binding. No contradiction.

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

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

Two sentences, no filler. The primary action is front-loaded and the Space behavior is explained efficiently.

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-one-by-id tool with annotations indicating read-only behavior, this definition covers the key invocation concerns: which id to pass, Space scoping, and per-call override. No output schema is required to make the call 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 50%. The space_id parameter already has a thorough schema description, and the prose reinforces its override behavior. The angle_id parameter is only implied by 'by id' but is not separately described; this is adequate for a simple id lookup.

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

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

The description uses a specific verb and resource: 'Fetch one angle by id.' This distinguishes it from list_ and other get_ helpers such as get_angle_preflight and get_angle_readout, though it doesn't explicitly name those siblings.

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

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

The description clearly explains the active Space scoping and tells the agent to use set_active_space to switch, or pass space_id to override for the call. It does not explicitly contrast with list_angles or related getters, but the by-id framing makes the basic usage obvious.

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?

Even with readOnlyHint present, the description adds substantial non-obvious behavior: it always returns a probabilistic range rather than a single value, and unresolvable plans come back as advice, not refusal or an error. This is the kind of nuance an agent cannot safely infer from the schema or annotation alone.

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

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

The description is compact and front-loads the most important usage signal: 'BEFORE spending.' Each sentence carries distinct information: the purpose, the return shape, the failure-mode behavior, and the scoping mechanism. There is no redundant or filler content.

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

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

Even without an output schema, the description covers the return type, its variability, the failure/advice behavior, and how to control scope — which is all an agent needs to invoke and interpret the result correctly. The tool's complexity is low, and this description fully compensates for the absence of structured output definitions.

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

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

The input schema already documents both parameters completely, including the meaning of count and the scoping behavior of space_id. The description reinforces this with 'candidate angle count' and 'override for this one call,' but adds little semantic value beyond what the schema already states.

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

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

The description states a concrete purpose: it simulates the budget-based stopping rule on the account's observed spend, CPC, and CVR, and returns a P20-P80 weeks-to-verdict range for a candidate angle count. The 'BEFORE spending' framing and 'never a single week' caveat make its function distinct from simple read tools like get_angle or get_angle_readout.

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 opening 'BEFORE spending' is a clear usage trigger, and the description gives concrete scoping guidance: use the active Space or pass space_id to override. It does not explicitly name alternatives like get_angle_readout or state when NOT to use the tool, so some inference is still required.

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

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

Annotations already mark the tool as read-only, and the description agrees without contradiction. It adds meaningful behavioral context by noting that delivery flags can mean part of the reported answer is driven by supply, not merit, and by stating that it never shows confidence that does doesn't actually exist. This goes beyond what the readOnlyHint annotation alone provides.

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

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

The most important idea is front-loaded with one phrase: 'Results read at the ANGLE level.' Then the description describes what fields to expect and the space-scoping caveat. Some of the phrasing is inventive but non-essential, so it is not maximally concise, yet every sentence carries real purpose.

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

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

Given that there is no output schema, the description provides a solid overview of the return composition and scoping behavior. It leaves minor gaps about pagination and whether empty results are possible, but for a read-only query tool the current level of detail is sufficient for a knowledgeable agent to recognize and 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?

All four parameters are documented in the schema with descriptions, so the schema coverage is 100% and the baseline of 3 is appropriate. The description mostly reinforces the space_id override behavior already described in the schema. Neither it substantially adds new parameter-level meaning, nor does it need to.

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

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

The description clearly states the tool returns angle-level results and enumerates exactly what is included: decision state, P(best), expected monthly loss, delivery flags, last state transition, and estimator provenance. This is specific about the resource and what it does. It does not explicitly contrast with siblings like get_angle or list_angles, so it does not fully earn a 5.

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

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

The description implies this is the right tool when you need angle-level read values, and it gives clear context about scoping to the active Space or overriding space_id for a single call. However, it never states when not to use this tool or which sibling tool to prefer in which situation. That key decision remains unstated, so the usage guidance is implied rather than explicit.

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

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

Annotations already declare readOnlyHint=true, and the description adds that the operation is scoped to the active Space with an optional override via space_id. This is useful behavioral context beyond the read-only flag, but it does not disclose error handling or return format.

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

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

Two short sentences, with the primary action in the first and scoping behavior in the second. No fluff or redundant content.

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

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

For a simple getter with two parameters and no output schema, the description covers the key operational aspects: what it fetches, the space scope, and the override mechanism. It lacks explicit return-value information, but that is not necessary for a straightforward read of an asset.

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

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

The schema provides a detailed description for space_id, but asset_id remains undocumented. The description's 'by id' hints at the asset_id parameter without adding format details; the parameter name itself is self-explanatory. With 50% schema coverage, the description adds limited semantic value beyond what is already in the schema.

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

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

The description opens with 'Fetch one asset by id', which uses a specific verb ('Fetch') and resource ('asset') and clearly distinguishes it from list_assets and other getters. The additional scoping mention further clarifies the exact operation.

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

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

The description explains the tool's scope ('Scoped to the active Space') and directs users to set_active_space to switch, or to pass space_id for a one-off override. This provides clear context for space handling, though it does not explicitly name an alternative for fetching multiple assets.

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

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

Annotations include readOnlyHint=true, and the description adds 'Cheap, no side effects' plus the semantic role of scheduling.timezones. This goes beyond the annotation by explaining behavior and use implications.

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: the first front-loads the return values, the second adds cost and usage. Every word earns its place; no redundancy or filler.

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

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

Given zero parameters and no output schema, the description fully specifies what is returned (owner, plan, scope, scheduling.timezones) and when to use it. It is self-contained and leaves no critical 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?

The tool has zero parameters and the input schema is empty (100% coverage). Baseline 4 applies, and the description adds return-value semantics, which is more than sufficient for a parameterless tool.

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: 'Return the owner, plan, and scope set of the API token currently in use'. It clearly distinguishes this from sibling getters by focusing on the token itself rather than platform entities.

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

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

Provides clear usage contexts: 'useful as a connection check and to learn your scheduling timezone before setting ad schedules'. It does not explicitly exclude alternatives, but none apply given the token-focused scope.

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

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

Annotations already provide readOnlyHint=true, but the description adds value by explicitly stating 'no side effects' and 'cheap to poll', which informs the agent that frequent calls are safe. It also details the specific data returned (events with budget crossed, spend measured, campaigns paused), giving a clear behavioral picture beyond the annotation.

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

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

The description is a single, well-structured sentence that front-loads the core purpose ('Read the Emergency Brake state on its own') and packs additional detail into each clause without redundancy. Every piece of information serves a purpose, making it concise yet comprehensive.

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

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

Despite the lack of an output schema, the description fully explains what the tool returns: armed status, engagement status, recorded events with details, and overridden levels. It also adds operational context ('cheap to poll, no side effects'). For a simple read-only tool with no inputs, this is complete.

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

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

The tool has zero parameters and the schema is empty, so the description does not need to explain parameter meaning. Per the calibration guide, a tool with 0 params receives a baseline of 4. The description appropriately focuses on the output rather than inputs.

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

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

The description uses the specific verb 'Read' and clearly identifies the resource as the Emergency Brake state, enumerating exactly what it returns (armed, engaged, events, overrides). This distinguishes it from the sibling tool 'release_brake', which is an action tool.

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

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

The phrase 'on its own' indicates this is a standalone status-check tool, and 'Cheap to poll, no side effects' implies it can be called frequently for monitoring. However, it does not explicitly name alternatives or state when not to use it, so it falls short of a 5.

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

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

The readOnlyHint annotation is reinforced and expanded by the description, which details exactly what is returned (budget config, caps, currency, brake state, paused campaigns). It also discloses the scope constraint (active Space). This adds meaningful behavior beyond the annotation alone.

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

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

The description is four short sentences with a clear front-loaded verb and resource. The long list of return values is necessary and organized with colons and commas, avoiding redundancy. The 'Read-only' phrase is slightly redundant with the annotation but still brief.

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?

Even without an output schema, the description enumerates all the data the tool returns, including budget, caps, currency, and brake engagement details. It also specifies the active Space scoping. For a getter with no parameters, this is fully sufficient to understand 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?

The input schema has zero parameters, so schema coverage is trivially 100%. The description's reference to the active Space is a contextual scoping, not a parameter. With no parameters, the baseline score of 4 applies.

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

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

The description clearly states the tool reads the account's budget and Emergency Brake state, listing specific attributes. However, it does not explicitly distinguish itself from the sibling get_brake_status, which likely covers the brake-state portion. The verb and resource are specific, but sibling differentiation is absent.

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 notes the operation is read-only and scoped to the active Space, providing clear context for when to invoke it. It doesn't mention alternatives or exclusions, such as using get_brake_status for brake-only queries. Thus it offers clear context but no explicit alternative guidance.

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

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

Annotations already declare readOnlyHint=true, and the description adds meaningful behavior: the inclusion of brand voice profile when set, scoping to the active Space, and the one-call override via space_id. It does not contradict annotations and provides context beyond the structured data.

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

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

Two sentences, front-loaded with the core action and details, with no fluff. Every clause adds value: what is fetched, what is included when set, scoping, and how to override.

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-get read-only tool with no output schema, the description adequately hints at return contents (business plus brand voice profile) and explains the Space scoping. It does not mention error cases (e.g., not found), but the tool's simplicity and readOnlyHint keep this from being a major 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?

The description reinforces the space_id override meaning already present in the schema, but business_id has no schema description and the description only says 'by id' without format or type guidance. With 50% schema coverage, the description partially compensates but leaves business_id vague.

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

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

Description uses a specific verb ('Fetch one business by id') and identifies the resource (business) with a clear scope (single vs. list). It also distinguishes from siblings like list_businesses and update_business by emphasizing the read-only retrieval of a single entity and the optional brand voice profile.

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

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

The description clearly states the active-Space scoping and directs the user to set_active_space for switching or pass space_id to override. This gives actionable context on when to use the tool, though it does not explicitly name an alternative for fetching all businesses (list_businesses).

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 annotation, the description discloses important behavioral nuances: adScheduleStructured is canonical, adSchedule is a legacy echo, timezone semantics, and the Microsoft-only searcher timezone flag. It also clarifies that scoping defaults to the active Space and can be overridden, which is essential operational knowledge.

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

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

The description is well-structured, front-loaded with the core purpose, and uses subsequent sentences for schedule field clarifications and scoping. It is slightly dense with adSchedule technical details, but each sentence contributes meaningful information and there is no fluff.

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

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

With no output schema, the description takes on the burden of explaining return value nuances. It thoroughly covers the tricky adSchedule fields, timezone behavior, and Space scoping, leaving little ambiguity for the agent. The only omission is error/not-found behavior, but that is not critical for a get-by-id tool.

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

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

Schema coverage for parameters is 100%, with detailed descriptions for both campaign_id and space_id. The tool description does not add new parameter-level semantics beyond what the schema already states; it merely restates the scoping override concept. This meets the baseline for full schema coverage.

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

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

The description opens with a specific verb and resource: "Fetch one campaign by id." It clearly differentiates from sibling tools like list_campaigns and get_campaign_asset by focusing on a single campaign object retrieval. The mention of returning "the full campaign object" further reinforces its singular scope.

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

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

The description explains the active Space scoping and explicitly points to set_active_space and the optional space_id override for one-off calls. It does not explicitly contrast with list_campaigns, but the context implies use cases for fetching a single known campaign.

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

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

The readOnlyHint annotation already signals a safe read operation, and the description adds meaningful context about Space scoping and the space_id override behavior. This goes beyond the annotation without contradicting it, though it does not detail return format or error cases.

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

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

The description is two sentences, front-loaded with the action, and succinctly explains the scoping override. Every sentence serves a purpose with 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?

For a simple read operation, the description covers the essential aspects: what is fetched, the scope, and how to override. The presence of readOnlyHint and clear purpose makes the tool self-contained without needing to explain return values or side effects.

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

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

The schema covers space_id in detail, and the description reinforces its override purpose. However, campaign_asset_id is only implicitly defined by the phrase 'one campaign-asset link' and lacks any schema description. With 50% schema coverage, the description partially compensates but leaves the required parameter undefined.

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

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

The description opens with 'Fetch one campaign-asset link,' which uses a specific verb and resource, clearly distinguishing this from listing tools like list_campaign_assets or getting the asset itself via get_asset. The scope to a single item is explicit and matches the singular tool name.

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

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

The description provides clear context on Space scoping and how to override with space_id or switch via set_active_space. It does not explicitly mention when not to use this tool or name alternatives, but the singular 'one' implies use for individual fetches rather than lists.

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

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

The description is consistent with the readOnlyHint=true annotation, which is good. Beyond that annotation, it adds an important behavioral fact: the fetch is bound to the active Space unless space_id is supplied, plus the override allows reading another Space without changing the session binding.

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

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

Two tight sentences put the primary action first, then a single sentence covers Space-scoping, switching, and the per-call override. There is no filler or redundant restating.

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 single-fetch operation with two parameters and no nested objects, the description covers the required concept_id, the consequential Space-scoping, and the override path. An agent has everything necessary to invoke it correctly, despite the lack of an output schema.

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

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

The schema fully documents space_id but leaves concept_id as a bare string; '...by id' in the description adds some meaning, clarifying that concept_id is the lookup key. It does not give any formatting or type guidance beyond that, so it's helpful but not comprehensive.

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

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

The description opens with 'Fetch one concept by id,' which states a specific verb, a clear resource, and the primary lookup criterion. This decisively distinguishes it from list_concepts, create_concept, update_concept, and delete_concept, even without naming 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?

It clearly says the tool reads a concept in the active Space and points to set_active_space as the way to switch Spaces, with space_id as an optional one-call bypass. It gives solid context for when to call this vs. switching Spaces, although it doesn't explicitly name list_concepts as an alternative for multi-concept fetches.

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, but the description adds behavioral context by explaining the tool is scoped to the active Space and that space_id can override this for one call. This clarifies the dependency on session state, which is valuable beyond the read-only hint.

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

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

The description is two concise sentences, front-loaded with the primary action and followed by necessary scoping context. No wasted words, every sentence contributes value.

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

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

For a simple get tool with readOnlyHint and no output schema, the description covers the core purpose, scoping, and override mechanism. It doesn't mention return format or error cases, but these are reasonably inferred for a fetch-by-id operation, and the description is sufficient for an agent to select and invoke the tool.

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

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

The schema covers space_id in detail, but conversion_action_id has no description. The description adds clarity by indicating the tool fetches by id, and mentions space_id override, but does not fully compensate for the missing conversion_action_id format or constraints. Schema coverage is 50%, so the description provides only marginal added meaning.

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

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

The description clearly states the action: 'Fetch one conversion action by id.' This is a specific verb (fetch) with a specific resource (conversion action) and scope (by id), differentiating it from list_conversion_actions and other get_* tools. The resource and operation 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 provides context on space scoping and points to set_active_space for switching, with an option to override per call. It implies this tool is for fetching a single known ID rather than listing all, though it doesn't explicitly mention list_conversion_actions as an alternative for browsing.

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 include readOnlyHint=true, and the description does not contradict that. It adds valuable behavioral context beyond the annotation by detailing what the tool returns, including specific issue codes, and by explaining the active-Space scoping and override mechanism.

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

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

The description is front-loaded with the primary action and then packs relevant detail into three sentences. The list of issue codes is extensive but useful for an agent deciding to use the tool. Each sentence earns its place, though the first sentence is somewhat dense.

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 return values, and it does so thoroughly: match rate, upload failures, last-event age, issue codes, and trust line. It also covers scoping and override. It doesn't mention error cases or return format explicitly, but it's complete enough for selecting and invoking the tool.

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

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

Schema coverage is 100% for the single optional space_id parameter, and the schema description already explains the default and override behavior. The tool description repeats this but doesn't add significant new meaning beyond the schema, so the baseline of 3 is appropriate.

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

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

The description uses a specific verb+resource ('Return conversion-loop health for the active Space') and clearly enumerates the exact outputs (per-source match rate, uploads accepted vs partial-failure, last-event age, issue codes, trust line). This distinguishes it from sibling tools like get_conversion_status or get_conversion_report by focusing on health/diagnostic state.

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

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

The description explicitly identifies the use case as 'The "is the loop working / how confident" check', giving clear context for when to invoke it. It also explains scoping behavior and points to set_active_space as a related tool, though it doesn't explicitly mention alternatives to avoid.

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

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

The annotation readOnlyHint=true already establishes safety; the description adds useful behavioral context about the active Space scoping and the ability to override it. However, it does not explain the return format or pagination behavior, so it does not fully disclose all behavioral traits.

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

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

The description is three concise sentences with the primary function front-loaded, followed by filter usage and scope details. Every sentence adds value and there is no redundant wording.

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 no output schema, the description covers purpose, filters, and scope, and points to the OpenAPI spec for further details. It is sufficient for an agent to invoke correctly, though a brief note on response structure would have made it more 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?

Although the schema covers space_id with a description, the description goes further by naming additional query-param filters (period, platformId, dates) that can be passed as keyword arguments, which is especially valuable because additionalProperties=true and these filters are not in the schema. This adds meaning beyond the structured schema.

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

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

The description clearly states the tool returns a 'value-aware conversion report' with specific metrics (conversions, conversion value, ROAS) and the purpose of verifying Target ROAS bidding. This distinguishes it from other report/stat tools like get_performance_stats by focusing on conversion value and ROAS.

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

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

It provides clear context for when to use the tool ('so bidding toward Target ROAS can be verified') and describes scope handling via set_active_space or space_id override. It does not explicitly name alternative tools or exclusions, but the guidance is sufficient for basic selection.

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

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

ReadOnlyHint is already true, and description adds behavioral context: returns aggregates and recent uploads, scope is active Space unless overridden, and it is the 'cheapest way' (lightweight). No contradictions.

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

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

Three sentences pack a clear purpose, usage context, and scoping instructions without redundancy. Every sentence adds value.

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

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

For a read-only status tool with optional filters, the description fully frames return fields and scoping. No output schema exists, but the listed return content suffices.

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 descriptions cover all three parameters thoroughly (space_id override, action_ids alternative, campaign_id filter). Description adds no extra parameter syntax beyond schema, so baseline 3 applies.

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

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

The description clearly states the tool returns offline-conversion upload status for the active Space, including total count, last upload time, total value, and recent uploads. It also frames the use case as verifying the Callomat booked-call attribution loop, distinguishing it from conversion-health or conversion-report siblings.

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

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

It specifies when to use: 'cheapest way to verify the Callomat booked-call attribution loop' and explains scoping to the active Space with set_active_space or space_id override. However, it does not explicitly name alternatives or exclusion criteria.

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 annotation, the description discloses that the vocabulary is versioned and append-only, which meaningfully informs an agent that new entries may appear and existing ones are not replaced. It does not describe response shape, but for a read-only vocabulary lookup that is acceptable.

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

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

The description is compact, front-loaded with the resource definition, and every phrase earns its place. The second sentence adds behavioral and usage guidance without padding.

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

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

Given a single optional parameter, no output schema, and a safe read-only annotation, the description gives enough for an agent to select and invoke the tool appropriately. It does not spell out the exact response fields, but the tagging instruction implies the needed output well enough for this simple retrieval tool.

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

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

The only parameter, space_id, is fully described in the schema with behavior for defaults and overrides, and schema coverage is 100%. The description itself adds nothing about parameters, but the schema already carries that burden.

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

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

The description clearly identifies the resource: the closed creative vocabulary used by the angle plane, listing angle types, concept attributes, and business categories. It is specific enough to distinguish from tools like get_angle or list_angles, though it phrases the purpose as a definition rather than an explicit 'returns/gets' 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?

The description gives a concrete usage rule: tag with exact ids from this vocabulary and never use free text. It does not name sibling alternatives or state explicitly when not to use the tool, but the tagging instruction makes the practical context clear.

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

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

Annotations provide readOnlyHint: true, and the description adds valuable behavioral context: the operation is scoped to the active Space and can be overridden with space_id. This goes beyond the annotation's simple safety hint and explains a session-dependent 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 sentences, with the first sentence giving a clear, front-loaded purpose and the second adding scoping behavior. No unnecessary words or repetition.

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

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

For a simple read tool with readOnlyHint and no output schema, the description covers the core purpose and the space-scoping nuance. It omits details like not-found behavior or return format, but these are not critical given the tool's simplicity and the existing annotations.

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

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

The schema already thoroughly describes space_id, but keyword_id has no description. The description adds minimal meaning by stating 'by id', which implies keyword_id is the identifier. With 50% schema coverage, the description does not fully compensate for the undocumented keyword_id 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 'Fetch one keyword by id' clearly identifies the action (fetch), the resource (one keyword), and the retrieval mechanism (by id), distinguishing it from list_keywords and other get_* tools. It also adds scoping context, making the purpose unambiguous.

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

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

The description states the tool is scoped to the active Space and explicitly directs users to set_active_space for switching or pass space_id to override per call. This provides clear context for use, though it does not explicitly contrast with list_keywords for fetching multiple keywords.

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

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

The annotations provide readOnlyHint=true, so the read-only behavior is already declared. The description adds valuable context: the data is over a 'configured window', filters are passed as query params, and the operation is scoped to the active Space. This goes beyond annotations by explaining the scoping mechanism and the nature of the returned aggregates.

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

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

The description is three sentences, each serving a distinct purpose: stating the return value, explaining filter usage, and clarifying Space scoping. There is no redundant text or filler. It is compact, front-loaded with the core action, and every sentence adds value.

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

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

The tool has no output schema, so the description partially covers the return fields by listing impressions, clicks, conversions, and spend. It also provides the endpoint reference for more details. It doesn't specify the response structure (e.g., array vs object), but given the readOnly annotation and the mention of the spec, it is reasonably complete for an agent to invoke correctly. A minor gap is the meaning of 'configured window', which is left unexplained.

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

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

The schema defines space_id with a clear description and allows additional properties, but doesn't explain that additionalProperties correspond to query-param filters. The description explicitly states to pass query-param filters as keyword arguments and references the OpenAPI spec for the full set. This significantly enriches the parameter semantics beyond the schema alone.

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

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

The description clearly states the tool returns aggregated performance stats (impressions, clicks, conversions, spend) over a configured window. This specific verb+resource+scope distinguishes it from sibling getters like get_ad or get_campaign, which fetch individual entities. The mention of 'aggregated' and 'performance stats' makes the purpose unambiguous.

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

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

The description explains how to use query-param filters via keyword arguments and points to the OpenAPI spec for the full filter set. It also clarifies the Space scoping and how to override it with space_id or by using set_active_space. While it doesn't explicitly name alternative tools to use instead, the context is clear that this is the tool for aggregated stats and not for single-object data.

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 include readOnlyHint=true, and the description adds rich behavioral detail beyond that: status semantics, terminal states, watchdog reaping, structured errorDetails for Google/Microsoft, and space scoping. No contradiction with the read-only hint.

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

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

The description is a single, dense paragraph where every sentence conveys operational value—status meanings, error handling, and scope behavior. No fluff or repetition.

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

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

Despite no output schema, the description explains return fields, all possible statuses, error detail structure, and space scoping. This is sufficient for an agent to invoke the tool and interpret results without ambiguity.

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

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

Schema coverage is 100%, and the description adds context by explaining that space_id overrides the active Space for this call and sync_id comes from trigger_sync. This reinforces but also enriches the schema descriptions.

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

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

The description clearly states it 'Return a sync's status, per-campaign progress, totals, and structured errors,' using a specific verb and resource. It distinguishes from siblings like list_syncs (listing) and cancel_sync (cancellation) by focusing on status retrieval for a specific sync.

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?

Provides detailed guidance on interpreting effectiveStatus, including when to keep polling, the stalled watchdog behavior, and terminal states. It mentions set_active_space for switching scope, but does not explicitly compare to alternative sync-related tools, so it falls short of full when/when-not guidance.

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

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

Annotations already provide readOnlyHint=true, and the description does not contradict this. The description adds valuable behavioral context: the mutually exclusive required IDs (a constraint not reflected in the schema's required list), the Space scoping behavior, and how campaign_id expands the scope. It does not mention pagination or return format, but given the annotation coverage, the added context is significant.

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

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

The description is two sentences long, front-loaded with the core purpose, then the critical constraint, then the scoping behavior. Every clause earns its place with no filler or redundancy. It is highly scannable and efficient.

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 tool with no output schema, the description gives the essential selection rules and scoping mechanism. The main gap is that it does not describe what the response items look like (e.g., whether each binding includes full asset objects or just IDs), but this is not strictly required without an output schema. The description is sufficient for an agent to decide when to call the tool and set up valid 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%, so the schema already documents each parameter. The description adds essential semantic value beyond the schema by stating the 'exactly one of ad_id / ad_group_id / campaign_id' mutual-exclusion rule, which the schema does not encode. It also clarifies the space_id override behavior. This elevates it above the baseline 3 for high schema coverage.

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

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

The description clearly states the tool 'List asset-to-ad / ad-group attachments', which is a specific verb+resource that distinguishes it from sibling tools like list_assets (which lists assets themselves) and list_campaign_assets. The added detail about campaign_id returning 'every ad-level binding' further disambiguates its scope.

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

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

The description explicitly states the core usage constraint: 'Exactly one of ad_id / ad_group_id / campaign_id is required', and explains the behavior for campaign_id. It also directs users to set_active_space for switching spaces or passing space_id to override. However, it does not explicitly contrast with list_assets or say 'use this instead of X when you need bindings' — the distinction is implicit rather than explicit.

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

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

The readOnlyHint annotation already indicates a safe read operation. The description adds valuable behavioral context by noting it is 'Scoped to the active Space' and that space_id overrides for one call, and that it only covers 'visible campaigns.'

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

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

Two concise sentences front-load the core purpose and immediately follow with scope control. Every sentence earns its place with no fluff.

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

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

The tool is a simple list operation with 3 fully described parameters and no output schema. The description covers the key scoping behavior and ambiguity about visible campaigns. It is complete for practical use, though it omits explicit mention of pagination (already covered by schema).

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

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

Schema coverage is 100%, so all parameters are already described. The description repeats the space_id override concept already present in the schema, adding no new semantic detail beyond what the schema provides.

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

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

The description clearly states 'List ad groups across visible campaigns,' which specifies the exact action and resource. It distinguishes itself from sibling tools like list_ads and list_campaigns by focusing on ad groups, and adds scoping context.

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

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

It provides clear guidance on when to use the tool: it operates on the active Space, with a pointer to set_active_space to switch and the option to override with space_id. It does not explicitly exclude alternatives but gives enough context for correct selection.

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

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

Annotations already declare readOnlyHint=true, and the description adds valuable behavioral context: the risk of response overflow when unscoped, the 'visible campaigns' filter, and the active Space scoping semantics with override capability. This goes beyond the annotation without contradiction.

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

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

Two sentences, front-loaded with the core purpose, and every clause earns its place: the first sentence defines the action, the second explains scoping and overflow risk. No redundancy or filler.

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

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

Given the tool's read-only nature, 100% schema coverage for parameters, and absence of an output schema, the description sufficiently covers scoping, response size risk, and Space behavior. Minor gaps include the unspecified interaction when both campaign_id and ad_group_id are provided, but overall it is complete enough for selection and invocation.

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

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

The schema provides 100% coverage for all five parameters, so the baseline is 3. The description adds meaning by explaining the recommended use of campaign_id or ad_group_id and the consequence of omitting them, which is not fully captured in the schema's individual parameter descriptions.

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

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

The description clearly states 'List ads across visible campaigns' with a specific verb and resource, distinguishing itself from sibling tools like get_ad, list_ad_groups, and list_campaigns by focusing on the ads collection. The mention of scoping options adds further precision.

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 recommends passing campaign_id or ad_group_id to scope results server-side and warns that omitting them returns the whole Space, which can overflow the response budget. It also instructs users on managing the active Space via set_active_space and the space_id override, providing clear context but no explicit comparison to alternative list tools.

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

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

Annotations already carry readOnlyHint=true, so the safety profile is covered. The description adds genuinely useful behavioral context beyond that: output is scoped to the active Space, the scope can be locally overridden with space_id, and angles are business-scoped with results decided at the angle level. No behavior contradicts the annotation.

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, roughly 45 words, with the action and scope front-loaded in the first sentence; the second sentence gives the override semantics. Every clause earns its place — the domain definition, the scope binding, and the alternative path are all present with zero 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 zero-required-parameter, read-only list tool with 100% schema coverage, nothing needed for a correct call is missing: pagination mechanics live informatively in the cursor parameter explicitly referencing meta.nextCursor, return limits are in the schema, and scope override is in the description. The output schema is absent but unnecessary here since list endpoints of this shape have self-evident returns.

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% — all five optional parameters have type, range, pattern, and description, including defaults and max for limit and pagination for cursor. The description adds only indirect context (angle is business-scoped, which makes business_id semantically coherent) but no parameter-specific detail, so the baseline of 3 is appropriate.

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

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

States a specific verb plus resource in the very first clause — list the angles — and immediately defines what an angle is (claims your ads argue) plus its scoping trait (business-scoped, the unit results are decided at). This clearly separates it from sibling list tools like list_ads or list_concepts, and its plural verb distinguishes it from the singular get_angle.

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

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

Gives explicit operational context: the tool reads from the active Space and tells the agent exactly how to redirect — set_active_space to switch or pass space_id to override for just this one call. It does not explicitly name an alternative tool for retrieving a single angle, but the list/get verb contrast and the sibling set make that distinction natural rather than ambiguous.

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, so the safety profile is known. The description adds the ownership and space-scoping behavior, including the override capability, but doesn't detail pagination or return format.

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 that front-load the tool's purpose and include only essential scoping guidance.

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

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

The description, schema, and annotations together cover the tool's purpose, scoping, and safety. The lack of output schema is fine for a simple list operation, and pagination is documented in 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?

The schema has 100% coverage for all three parameters, so the description doesn't need to add parameter details. It does reinforce the space_id semantics by explaining the active Space concept, but no additional meaning beyond the schema.

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

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

The description clearly states it lists assets owned by the token's user, with a specific scope (active Space). This distinguishes it from sibling list tools like list_ad_assets or list_campaign_assets.

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

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

It explains scoping to the active Space and points to set_active_space for switching, plus offers space_id override for a single call. This is clear context for when/how to use, though it doesn't explicitly contrast with alternatives.

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

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

The readOnlyHint annotation already declares the tool safe, and the description adds valuable behavioral context: the scoping to active Space and the ability to override with space_id. It also clarifies the entity definition, which helps set expectations for the data returned. No contradictions with annotations.

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

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

The description is two sentences, front-loaded with the core purpose, and every clause earns its place. It defines the domain, explains scoping, and references the alternative approach in a compact, readable manner.

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 strong annotations and full schema coverage, the description is complete. It explains the domain concept (business), scoping behavior, and override option. No output schema is present, but the return value is implied by the list action and pagination schema. No additional context is needed.

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

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

The schema already covers all parameters (100% coverage), setting a baseline of 3. The description adds semantic value by explaining the 'space_id' override mechanism and its relationship to set_active_space, which goes beyond the schema's technical description. It also links the pagination parameters to typical list behavior implicitly.

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

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

The description uses the specific verb 'List' and clearly identifies the resource as 'businesses', with a clarifying definition of what a business is in this context (school, course, SaaS product, etc.). It also distinguishes itself from sibling list tools by focusing on the 'business' entity and notes the scoping to active Space, which is a unique aspect.

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

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

The description provides clear usage context by explaining that the list is scoped to the active Space and explicitly instructs to 'see set_active_space to switch, or pass space_id to override'. While it doesn't explicitly mention alternatives like get_business, the context is sufficient for a list tool, and the scoping guidance is practical.

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 annotation, the description discloses non-obvious behavioral constraints: a mandatory filter (at least one of campaign_id/asset_id), default scoping to the active Space, and the ability to override with space_id for a single call. These are essential operational details not implied by the annotation alone.

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

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

The description is two sentences with the primary action front-loaded. Every clause contributes a distinct piece of information: the action, the required filter, and Space scoping. No redundant or filler words.

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

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

The description covers the essential context: the action, required filter, Space scoping, and override. With 5 well-documented parameters and no output schema, it is mostly complete. A minor gap is that it doesn't describe the return structure or pagination behavior beyond the schema's cursor description, but this is not critical for a list operation.

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

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

The schema already covers all parameters with 100% description coverage, so the baseline is 3. The description adds the crucial cross-parameter constraint that campaign_id or asset_id must be present, which is not reflected in the schema's required field list, and clarifies the space_id override behavior. This adds meaningful value beyond the schema.

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

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

The description clearly states the specific action ('List asset-to-campaign attachments') and the exact resource relationship, distinguishing it from sibling tools like list_assets and list_ad_assets. The verb 'list' and the resource 'asset-to-campaign attachments' 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?

It provides explicit context for when to use the tool: at least one of campaign_id/asset_id is required, and it explains Space scoping with a reference to set_active_space and the space_id override. While it doesn't explicitly name alternative tools for different attachment types, the context is sufficient for an informed 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?

Beyond the readOnlyHint annotation, the description adds useful behavioral context: results are fed by token visibility, and results are restricted to the active Space unless overridden. It also hints at return fields, though pagination specifics are left to 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?

Two information-dense sentences pack in the action, scope, return fields, and optional override. Nothing is redundant; 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?

The description completes the picture for a list tool: it tells what is returned, the scope constraints, and how to adjust scope. Given the schema already documents pagination parameters and there is no output schema, this is sufficiently complete.

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

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

Schema coverage is 100%, so the parameters are already fully described. The description reinforces the space_id parameter's behavior (override for one call) but adds no new detail about limit or cursor, meriting the baseline score of 3.

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

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

The description clearly states the action ('List campaigns'), the scope ('visible to this token'), and the returned data shape (array with id, name, type, budget, etc.). It effectively distinguishes from sibling tools like get_campaign and list_campaign_assets by focusing on the campaign objects themselves and Space scoping.

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?

Provides clear context on Space scoping: how the active Space is used, that set_active_space can change it, and that space_id can override one call. However, it does not explicitly reference alternatives (e.g., use get_campaign for a single campaign) or when-not-to-use the 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?

ReadOnlyHint is already true, and the description adds relevant behavior beyond it: results are scoped to the active Space, and a Space override applies only to this one call. This clarifies the session-scope behavior without contradicting the annotation.

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

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

The description is compact and front-loaded with the key meaning of the resource, then quickly explains the scoping behavior. Each sentence earns its place and there is no redundant wording.

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 with fully documented parameters, the description is essentially sufficient. It does not restate return shape, but pagination via cursor is documented in the schema and read-only behavior is provided by the annotation.

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 is already documented clearly in the input schema. The description merely echoes the space_id override concept; it does not add meaningful new parameter context beyond what the schema provides.

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

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

The description states a specific verb and resource: 'List concepts,' and defines what a concept is within this system ('ways of making an angle's claim'). This clearly differentiates the tool from related list operations and makes its domain obvious.

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

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

The description gives crisp context for when to use this tool and how to control its scope: use set_active_space to switch spaces or pass space_id to override for a single call. It does not explicitly name exclusions or alternative tools for individual lookups, but that is easily inferred.

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, so the read-only nature is covered. The description adds behavioral context about space scoping—that it's scoped to the active Space and can be overridden with space_id—which goes beyond annotations. It doesn't mention pagination, but the schema covers limit/cursor.

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

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

The description is two sentences, front-loaded with purpose, and every sentence earns its place. No redundancy or fluff.

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

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

For a listing tool with no output schema and simple optional parameters, the description provides a clear picture of purpose, usage context, and scoping. It could explicitly mention pagination behavior, but the schema already documents limit and cursor, making it sufficiently complete.

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

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

All parameters (limit, cursor, space_id) have descriptions in the schema, providing 100% coverage. The description adds no new parameter semantics beyond restating the space_id override behavior already documented in the schema, so 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 clearly states the tool lists conversion actions in the active Space and describes the configuration details returned (type, category, value settings, lookback windows). This specific verb+resource+scope distinguishes it from siblings like get_conversion_action or list_conversion_sources.

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

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

The description explicitly says 'Use before uploading a conversion so it lands on the right action' and provides scoping guidance, referencing set_active_space and the space_id override. This gives clear when-to-use context and mentions alternatives.

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

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

The annotations already declare readOnlyHint=true, and the description adds useful behavioral context beyond that: it clarifies the scope (active Space), the optional override via space_id, and what is returned. No contradictions with annotations; the description does not need to state read-only because the annotation covers it.

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

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

The description is three sentences, front-loaded with the core purpose, then the use case, then scope/override instructions. Every sentence adds value with no fluff or repetition of the title/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 simple read-only list tool with one optional parameter and no output schema, the description covers all needed context: what it lists, example source types, returned fields, how scope works, and how to change scope. It is complete and self-sufficient for an agent to invoke correctly.

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

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

Schema description coverage is 100%: the only parameter (space_id) is thoroughly described in the schema, including its pattern and default behavior. The description mentions the same override behavior but adds no new parameter details beyond the schema, so 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 clearly states the tool lists conversion sources connected to the active Space, with a specific verb ('List') and resource ('revenue/conversion sources'), plus examples of source types and returned fields (type, status, config). It distinguishes itself from sibling tools like create_conversion_source and list_conversion_actions by focusing on reading existing sources.

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

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

It explicitly tells the agent when to use the tool: 'Use to see which sources are feeding real conversions into Smart Bidding.' It also gives clear context about space scoping and directs to set_active_space for switching or to pass space_id for override. It does not mention explicit alternatives or when-not-to-use cases, but the guidance is sufficient for correct selection.

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

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

Beyond the readOnlyHint annotation, the description adds valuable context: empty list means no disapprovals (not a failure), return data includes review status, structured reasons, and affected markets. It also discloses the scoping behavior and the space_id override option, which is not evident from annotations alone.

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

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

The description is well-structured and front-loaded with the core purpose, followed by the efficiency hint, empty-list clarification, and scoping guidance. Each sentence serves a distinct informative function, with no redundancy or fluff.

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

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

For a read-only list tool with no output schema, the description fully explains what the call returns (review status, structured reasons, affected markets), clarifies empty results, and covers Space scoping and override. It provides sufficient context for an agent to select and invoke the tool correctly without needing additional information.

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

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

The input schema already provides complete descriptions for both platform and space_id (100% coverage). The description only reiterates the space_id override concept without adding new semantic detail, so it does not meaningfully enhance parameter understanding beyond the schema.

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

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

The description clearly states it lists every ad and keyword that is not being served (disapproved, limited, or area-of-interest-only), including review status and reasons. It distinguishes itself from sibling list tools like list_ads and list_keywords by focusing specifically on disapproval state.

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

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

The description explicitly positions this as the cheapest way to answer 'why isn't this ad running?' and provides clear scoping instructions (active Space, set_active_space, space_id override). It does not explicitly name alternatives like list_ads or list_keywords, but the phrasing 'without paging through every ad and keyword' implies them.

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 annotation, the description discloses important behaviors: the tool is scoped to the active Space by default, can return the whole Space if unscoped with a risk of overflowing the response budget, and supports per-call Space override via space_id. This adds meaningful context not derivable from annotations alone.

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

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

The description is two sentences, front-loaded with the core purpose, and every clause contributes meaning (scoping recommendation, space behavior, override option). No redundant or filler content.

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

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

For a list tool with no output schema, it explains scoping, Space behavior, and potential overflow. It does not explicitly state the return structure (e.g., list of keyword objects with cursor), but this is somewhat covered by cursor schema referencing meta.nextCursor. Overall adequate for the complexity.

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

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

The schema already provides 100% parameter descriptions, so the baseline is 3. The description adds value by explaining the 'server-side' scoping mechanism and the practical consequence of not using ad_group_id/campaign_id (overflow risk), which goes beyond the schema's individual field descriptions.

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

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

The description clearly states the tool 'List keywords across visible campaigns' with a specific verb and resource. It distinguishes itself from sibling tools like get_keyword or list_ads by naming the resource and mentioning scoping by ad_group_id/campaign_id.

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

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

The description provides clear usage context: recommends passing ad_group_id or campaign_id to scope results server-side and warns that omitting them may overflow the response budget. It also explains how to switch Space via set_active_space or override per call with space_id, but it does not explicitly contrast with alternatives like get_keyword.

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