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 only cover readOnlyHint=false and destructiveHint=false; the description adds real behavioral context — it creates or updates an asset link, returns the full created/updated object, derives campaignId, and is bounded by the active Space. The aside about single-image cards is opaque, and it doesn't warn whether an existing asset on the same slot is replaced.

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

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

Front-loaded with the action and the two scope branches, then supporting detail; no filler sentences. The clause about single-image cards is the one piece that is hard to parse and could be trimmed.

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

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

No output schema exists, and the description covers the return value ('full updated/created object'), the conditional parameter rules, and the Space scoping escape hatch. An agent has everything needed to call this correctly.

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

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

Schema coverage is 100%, but the description still adds information the schema cannot express: the conditional requirement of adId vs adGroupId keyed to scope, and the fact that campaignId is optional because it is derived. That is genuine semantic value beyond the structured fields.

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

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

Specific verb (attach) plus resource (asset to ad/ad group), and it explicitly enumerates the two supported scopes with their required IDs. It also contrasts itself implicitly with the campaign-level sibling by stating this is the scope that actually serves images/video on Display, Performance Max and 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?

Clear conditional guidance: scope=AD requires adId, scope=AD_GROUP requires adGroupId, and campaignId is derived when omitted. It also directs the agent to set_active_space or space_id for cross-Space writes. It never explicitly says when to prefer attach_asset_to_campaign instead, so it falls short of the 5 bar.

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 only carry readOnlyHint=true, so the description does the heavy lifting: it reveals that this mirrors the save-time gate, names the downstream error code it prevents, and discloses Space scoping plus the per-call override. What it omits is the result shape (boolean verdict vs. list of matches) and what a 'too close' response contains.

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

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

Three tight sentences, front-loaded with the core behavior, then the usage trigger, then the scoping caveat. No filler and nothing buried.

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

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

For a read-only preflight check with no output schema, the agent knows why to call it, when, and how to scope it. It lacks only what a response looks like and how to act on a positive similarity hit, which is a real but minor residual gap.

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

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

Schema coverage is 100% and space_id's semantics are already spelled out in the schema, so the description only restates it briefly. The description never mentions the nested businessId field or clarifies what texts accepts (single string vs. batch), leaving that entirely to the schema, so baseline 3 applies.

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

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

States a specific action (run the similarity check), a specific resource (ad copy vs tracked competitor ads), and even the second failure mode it detects (naming a competitor). No sibling tool in the list performs competitor-copy similarity, and the description makes that scope 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?

Explicitly prescribes the timing — 'Use before creating or updating ads to avoid a 409 COMPETITOR_SIMILARITY' — which tells the agent exactly when to reach for it. It also routes space scoping to set_active_space versus the space_id override, but gives no 'when not to use' guidance or alternative tool for other preflight checks.

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

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

Annotations declare readOnlyHint=false and destructiveHint=false; the description goes well beyond that by disclosing the state transitions (READY on success, FAILED on invalid image) and the UPLOAD_MISSING failure mode. It stops short of describing idempotency or whether a FAILED asset can be retried, which are relevant for a completion step.

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

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

Three sentences, all front-loaded: the action and sequencing first, then failure modes, then Space scoping. No filler and nothing an agent needs is buried.

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

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

No output schema exists, yet the description explains what the call determines (type, size, width, height) and what result state is set, so an agent knows what to expect on return. Combined with 100% schema coverage, nothing material is missing.

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

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

Schema coverage is 100%, so baseline is 3. The description restates that asset_id scoping comes from the active Space and that space_id overrides it for one call, but this largely duplicates the schema text rather than adding new syntactic or format detail.

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

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

States a specific verb and resource ('finish a two-step upload', 'marks the asset READY') and positions itself precisely in the upload sequence relative to start_asset_upload and upload_asset. An agent can distinguish it from all siblings without opening the schema.

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

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

Explicitly says to call it after the PUT, and names the alternative path for Space scoping (set_active_space vs. passing space_id). It does not state any when-not conditions, but the prerequisites for the call are 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?

Beyond the annotations, the description discloses the state transition (DRAFT to PAUSED), refusal conditions tied to app-side checks, the fact that nothing reaches a platform until trigger_sync, and the subsequent pause behavior. It also states that the campaign is returned and explains Space scoping, which is substantial behavioral context for a non-destructive mutation.

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 action and state transition, then layers in refusal conditions, sync implications, return behavior, and Space scoping. Every sentence carries operational value and there is no redundant 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 mutation tool with no output schema, the description covers the important state change, refusal conditions, downstream sync behavior, return value, and Space scoping. Combined with complete parameter descriptions and annotations, an agent has enough context to invoke it correctly.

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

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

Schema description coverage is 100%, so the schema already documents both campaign_id and space_id. The description reinforces that campaign_id refers to a draft campaign and notes the space_id override, but it adds little technical meaning 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: "Confirm a DRAFT campaign: moves it to PAUSED." It also distinguishes the action from other campaign changes by explaining that no other change can take a campaign out of DRAFT and that this is the one way to do so.

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

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

It gives explicit when-to-use guidance for draft campaigns and when-not conditions: confirmation is refused while the campaign builder is still writing or while a required question is unanswered. It also clarifies the downstream path, noting that nothing reaches a platform until trigger_sync and that the campaign stays paused until status is set to ENABLED and synced again.

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 mutation and not destructive. The description adds meaningful behavior beyond annotations: it triggers ad reading and requires prior user agreement, though it does not cover reversibility or error behavior.

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

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

The effect is front-loaded, followed by the call precondition and scoping note. Every sentence carries useful information with no 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 mutating confirm action with a nested body, the description covers purpose, precondition, effect, and Space scoping. It leaves minor gaps around rejection guidance and result/error behavior, but the schema carries the field-level detail.

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 competitor_id, body, and the space_id override. The description reinforces Space scoping but adds no new detail about the nested IdentityConfirm body or its required fields.

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: confirming that a library account belongs to a competitor. It also names the immediate outcome, that Growomat starts reading its ads, which lets an agent distinguish it from discovery and rejection 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 gives a clear prerequisite: only call once the user has agreed the match is right. It also explains the Space scoping and points to set_active_space for switching, but it does not explicitly route to reject_competitor_library_account when the match is wrong.

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

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

Annotations already declare readOnlyHint=false and destructiveHint=false, so the write/non-destructive profile is known. The description adds meaningful context beyond that: the ad is stamped with provenance 'user' and will 'count in angle results from then on' — a persistent side effect the agent needs to know. This is substantive behavioral disclosure.

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 core action is front-loaded, followed by effect, user-agreement caution, and Space scoping. Every sentence carries a distinct piece of information with little waste, though the density of domain jargon slightly reduces readability.

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

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

For a nested-body mutation tool with no output schema, the description covers action, side effect, usage precondition, and Space scoping — the essentials an agent needs to call it correctly. It does not explain what a successful confirmation returns, but with no output schema that gap is minor.

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% at the top level, but the nested items fields (adId, angleType) carry no schema descriptions. The description compensates by explaining adId names an active ad and angleType comes 'from the closed vocabulary' to correct the reading, adding semantic meaning beyond the bare schema. It does not enumerate the vocabulary values, keeping it just shy of a 5.

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

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

The description states a specific action — turning readings into angle stamps on active ads — and distinguishes it from the read-side sibling get_own_ad_reading. The domain jargon ('readings', 'angle stamps') is somewhat opaque, but the verb+resource+effect is clear enough for an agent to identify it as the write/confirmation counterpart.

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?

'Ask the user first; confirm only ads they agreed to' gives an explicit precondition for use, which is the key gating behavior. It also points to set_active_space and the space_id override for scoping. It stops short of naming when a different confirmation tool applies, but the core when-to-use is well covered.

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

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

Annotations already declare this is a non-read-only but non-destructive mutation. The description adds meaningful behavior beyond that: the image must be at least 640 × 640, an image can come from attach_asset_to_ad or creative.imageUrl, validate_export surfaces platform refusals, and the tool returns the full created object. It does not cover permissions, rate limits, or duplicate-ad behavior, so not a 5.

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

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

Purpose is front-loaded and the dense paragraph conveys a lot without obvious filler. However, the card-format rules are packed into a long em-dash-heavy run-on, and a short structured breakdown by format would be more scannable for an agent.

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

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

For a complex nested-schema mutation with no output schema, the description covers return values, required image workflow, validation/preview, and active-Space scoping. It only documents search ads and OPENAI_CHAT_CARD in detail despite an enum of 19 ad formats, leaving agents to infer handling for VIDEO_AD, REDDIT_*, META_*, LINKEDIN_*, etc.

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 substantially exceeds that by explaining which fields each format reads: search ads consume headlinePart1–3 and description/description2; OPENAI_CHAT_CARD uses headlinePart1 as a 3–50 character title, description as a body up to 100, and _native[platformId].postTitle/postBody as an alternate copy path. That is real semantic meaning not present 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?

Opens with a specific verb and resource: 'Create a new ad inside an ad group.' This clearly distinguishes it from update_ad and create_ad_group, and the agent knows exactly what operation is being performed without reading the schema.

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

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

Explicitly routes the agent to upload_asset + attach_asset_to_ad before creating a card, and tells it to use validate_export to catch platform refusals and preview_campaign to see the card as sent. It gives clear workflow context and alternatives, though it does not state when-not to use this tool (e.g., use update_ad for existing ads).

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

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

Annotations already flag this as a non-read-only, non-destructive write. The description adds useful context beyond them: the call returns the full created object and is scoped to the active Space with a per-call override. It does not cover failure modes, duplicate-name behavior, or validation rules.

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

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

Three short sentences, all front-loaded with the operation first, then return behavior, then scoping. 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?

For a two-parameter mutation tool with fully documented schema and safety annotations, the description covers purpose, return shape, and space scoping. A note on required campaign existence or error behavior would close the remaining gap.

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

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

Schema description coverage is 100%, including detailed body fields and the space_id override semantics, so the schema does the heavy lifting. The description only echoes the space_id option and adds no syntax or constraint detail beyond the schema, matching the baseline 3.

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

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

The description gives a specific verb and resource ('Create a new ad group') and states the parent relationship ('under a campaign'), which separates it from update_ad_group or create_campaign. It does not explicitly name the nearest siblings (update_ad_group, create_ad) to rule them out.

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 explains the space-scoping choice: use set_active_space to change sessions or pass space_id for a one-call override. It stops short of saying when to use create versus update, or what prerequisites (e.g. an existing campaign) must be met.

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 declare it is a non-read-only, non-destructive write. The description adds real behavior the annotations can't: the URL must stay reachable because it is fetched lazily on sync, store=true snapshots expiring links, every response carries previewUrl, and the full object is returned. That is substantive disclosure beyond structured fields.

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

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

Dense but front-loaded: the core create statement and mode split come first, then response and scoping notes. Every sentence carries information, though the phrasing is packed and slightly elliptical ('upload_asset is the simpler door for that').

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

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

For a nested-body mutation tool with no output schema, it covers the essential things an agent needs: creation modes, return shape (previewUrl, full object), and Space scoping. It leaves error/failure handling and the optional field set to the schema but nothing critical is missing.

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

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

Schema coverage is 100%, so the baseline is 3, but the description adds genuine meaning beyond the schema by explaining how url, data and store interact (pointer vs stored bytes) and the ephemeral-URL failure mode. Not a 5 because it repeats somewhat and omits any framing of the remaining optional fields.

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

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

Opens with a specific verb and resource plus the concrete asset kinds (image, logo, video), and immediately distinguishes itself from the sibling upload_asset. An agent can tell create_asset apart from upload_asset/update_asset without opening a schema.

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

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

Explicitly lays out the two operating modes: by-reference (body.url kept as a pointer) versus by-bytes (body.data base64, or url with store=true). It names the alternative ('upload_asset is the simpler door for that') and explains override behavior via space_id vs set_active_space.

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

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

Annotations already declare this is a non-read-only but non-destructive write operation. The description adds that it returns the full created object and that the brand profile governs generated ad and social copy, along with Space scoping details; it does not cover auth requirements or duplicate/failure behavior.

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

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

The description is front-loaded with the core action and fields, then covers the brand profile, return behavior, and Space scoping. The sentences are compact and each adds 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?

For a create tool with a complex nested body but full schema coverage, the description does enough: it names required name/website, summarizes optional fields, explains brand behavior, states the return shape, and documents Space scoping. Minor gaps around auth, duplicate handling, and advanced fields remain but are not critical 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?

Schema description coverage is 100%, so the schema already carries most parameter meaning. The description adds useful context for key pages as sitelinks and explains the brand profile's role, but it omits fields such as status, categoryId, logoUrl, and logoSource.

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, 'Register a new business', and immediately lists the core fields it accepts. This clearly separates it from retrieval tools like get_business or list_businesses and mutation tools like update_business.

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 the Space scoping behavior and names set_active_space as the way to switch, plus the space_id one-call override. It does not explicitly say when to use this versus update_business or how duplicate businesses are handled, but the intended 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 only declare it is not read-only and not destructive. The description goes far beyond: pushes are irreversible in one direction (a LIFETIME budget can never become daily), DRAFT campaigns are held until confirm_campaign, and the call is scoped to the active Space. It also states it returns the full created/updated object.

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

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

Front-loads what it does and which field is required, then layers constraints. It is a single dense paragraph with heavy nested parentheticals (lifetime budget example, space scoping) that slow parsing, but no sentence is truly expendable.

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

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

For a complex create with nested objects and no output schema, it covers the required fields, currency semantics, platform-specific extension handling, draft lifecycle, and Space scoping, while deferring shape details to the OpenAPI spec. Nothing an agent needs to invoke it correctly is missing.

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

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

Schema coverage is 100%, so the baseline is 3, but the description adds real meaning: _platformBudgets is required and only listed, switched-on platforms run; budget is a daily figure in the platform account's currency; _native is keyed by platform id and carries platform-only keys. The lifetime-budget example (budgetKind LIFETIME requiring MANUAL_CPC plus cpcBid) is genuinely non-obvious guidance.

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

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

States a specific verb and resource (create a new campaign) plus its defining constraint: it only runs on platforms listed in body._platformBudgets. It implicitly distinguishes itself from update_campaign, preview_campaign and confirm_campaign by describing the DRAFT-until-confirmed lifecycle, so an agent can pick it without opening a schema.

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

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

Routes the agent to concrete siblings for supporting facts: list_connections for currency, validate_export for per-currency minimums, set_active_space for scope, confirm_campaign for draft release, and set_ad_schedule/set_geo_targeting as preferred helpers. It gives clear context but stops short of saying when NOT to create directly (e.g. preview first).

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

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

Annotations already 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 only declare this is a non-read-only, non-destructive write. The description adds real behavioral context beyond that: platform-dependent mutation semantics where negative keywords are silently dropped, the fact that the full updated/created object is returned, and how the active-Space binding affects where the write lands.

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, action first, then platform caveat, then return behavior and scoping. Dense but every clause carries information; the middle sentence is slightly compressed in a way that takes a re-read.

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 annotations covering the safety profile, no output schema, and a fully documented nested body schema, the description covers the remaining agent-relevant unknowns: platform-dependent behavior and Space scoping. Anything further (match type rules, bid semantics) is legitimately deferred to the OpenAPI spec.

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

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

Schema coverage is 100%, so the baseline would be 3, but the description adds interpretive meaning for `body.text` (on chat platforms write keywords as the questions people ask) and clarifies the positive/negative distinction tied to `isNegative`. The `space_id` explanation largely restates the schema's own description, so it is not a full 5.

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

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

States a specific verb and resource ("Add a keyword to an ad group") that maps cleanly against siblings like update_keyword, delete_keyword, and list_keywords. It does not explicitly name a sibling it is not, so it stops short of full differentiation, but the operation is unambiguous.

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

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

It gives conditional guidance (on platforms without keywords, positives become plain-language context hints and negatives are dropped), points to validate_export as the authority for that behavior, and explains the Space scoping with set_active_space as the alternative and space_id as the per-call override. That is explicit when/how-to-route guidance rather than implied 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?

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?

Beyond the annotations (which only declare readOnlyHint=false and destructiveHint=false), the description discloses quota consumption ('one monthly library lookup'), caching ('unless today's result is cached'), and confirmation gating ('Nothing is read until one is confirmed'). It does not explain the non-read-only nature implied by the annotation or any permission requirements.

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

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

The description is four sentences, front-loaded with the core purpose and evidence criteria. Every sentence adds value: the evidence factors, the confirmation gating, the quota/caching cost, and the space scoping. 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?

Given no output schema, the description covers what the tool does, how it evaluates matches, its side effects (lookup quota, caching), and session scoping. It does not describe the return format (e.g., list shape, evidence fields) but the evidence parenthetical implies useful output; completeness is strong but not exhaustive.

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 context for space_id (override vs set_active_space) but does not mention the force parameter or its cache-bypass behavior beyond a general caching note; the schema already documents all parameters.

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

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

The description states a specific verb (search) and resource (public ad library accounts matching a competitor), and the evidence criteria (website match, name match, verification) clearly distinguish it from sibling tools like list_competitors or list_competitor_ads.

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

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

It gives clear usage context: scoped to the active Space, with an option to override via space_id or use set_active_space. However, it does not explicitly state when not to use this tool or name the confirmation sibling (confirm_competitor_library_account) as the required next step, leaving some inference to the agent.

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

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

Annotations already declare 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?

readOnlyHint already covers safety, yet the description adds substantial behavior: metrics are ad counts 'never spend', the two sides of the comparison use asymmetric windows (their last `days` vs. own ads active now), coverage has three states (stamped/read/unknown), and verdict.basis=mixed requires a hedging phrase in the reply. That is exactly the extra context annotations cannot carry.

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 core comparison is front-loaded in sentence one and every subsequent sentence carries information an agent needs (coverage states, null causes, phrasing rule, scope). The third sentence is overloaded with nested parentheticals and could be split, costing it the top mark.

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 returns and does so: it defines the coverage field, the verdict field, its null/withheld semantics, and verdict.basis. Combined with the Space scoping note and remediation path, an agent has everything needed to call and interpret this tool.

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

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

Schema coverage is 100%, so the baseline is 3; the description earns above that by clarifying that `days` applies only to competitor ads while the business's side is 'active now', a semantic asymmetry the schema does not spell out. space_id is only restated in general terms (override for one call), which the schema already says.

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 comparison: competitor ad angles vs. the business's own active ads, explicitly in ad counts and not spend. The verb+resource are clear, though the opening sentence is convoluted ('Which claims the tracked competitors lead with compared with...'), and it never names a sibling such as get_angle_readout or get_competitor_coverage as the alternative, so differentiation has to be inferred.

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

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

It gives concrete branching guidance: when verdict is null, the withheld reason tells the agent what to do (own_ads_unread → call get_own_ad_reading and offer to confirm it), and it enumerates the other withholding causes. It also covers the Space-scoping decision (use active Space vs. pass space_id). What's missing is any statement of when to reach for this tool versus adjacent analysis 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?

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?

With readOnlyHint=true already covering the safety profile, the description adds genuinely non-obvious behavior: the brief deliberately excludes verbatim competitor text, which shapes how the caller should use the result, and it explains scoping/precedence between the session-bound active Space and a per-call space_id override. It does not describe the size or structure of the returned brief beyond a field list.

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

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

Three tightly packed sentences, each doing distinct work: what the brief contains, how to use it, and how Space scoping resolves. Zero filler and the most decision-relevant content (original-copy constraint) 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?

With no output schema, the description carries the burden of describing the return value and does so adequately by enumerating the brief's components. The nested body object is the main gap — an agent gets no hint about which identifiers are required or how they combine to select a brief. Space-override semantics are fully 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?

Schema coverage is 100%, so the baseline is 3. The description does add real meaning for space_id by explaining the override-vs-session precedence and default source, which goes beyond the schema text. However, the four selector fields inside the required body (businessId, adId, competitorId, angleType) — the ones that determine which brief is produced and whether it is mandatory — get no mention at all.

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 deliverable — a structured brief containing angle type, the shape of a competitor's offer, and the hook pattern — rather than restating the name. It clearly frames the output as an input for drafting original copy, which separates it from data-returning siblings like get_angle_readout or get_competitor_offers. It stops short of naming any sibling explicitly, so an agent must infer the boundary.

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

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

It gives a clear use context ('for writing ORIGINAL copy that argues a competitor's angle') and a hard constraint (never reuse competitor wording; write in the business's voice). It also documents the Space-selection behavior and names set_active_space as the alternative for changing scope. It does not state when to prefer it over get_creative_vocabulary or get_angle_gap, so the exclusion side is incomplete.

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?

Annotations already declare readOnlyHint=true, so safety is covered; the description adds real behavior beyond that by noting the accounts returned are only *confirmed* library accounts and that reads are scoped to the active Space session binding. The override semantics are conveyed, though the description does not cover failure behavior for an unknown competitor_id.

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

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

Two compact sentences, front-loaded with what is returned and followed by the scoping caveat. The scoping sentence largely restates the space_id schema description, which is mild redundancy but not enough to warrant trimming.

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

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

For a simple two-parameter read tool with no output schema, the description tells the agent what the result contains (competitor, confirmed ad library accounts, summary) and how the Space context is resolved. Nothing essential to calling it correctly is missing.

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

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

Schema description coverage is 100% and the space_id field already spells out the override-versus-session default in more detail than the description does. The description adds no meaning to competitor_id beyond what the schema states, 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 states the resource precisely — a single competitor returned with its confirmed ad library accounts and a summary — which lets an agent distinguish it from list_competitors (plural) in the sibling set. The verb is implicit ('one competitor with...') rather than an explicit 'get', but the singular scope is unambiguous.

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

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

Usage guidance is limited to Space scoping: read the active Space, use set_active_space to switch, or pass space_id as a one-call override. There is no guidance on when to choose this over list_competitors, get_competitor_coverage, or get_competitor_auction, so the retrieval-singular use case is only implied by the description.

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

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

Annotations already declare readOnlyHint=true, so the description needn't explain safety. It adds valuable context beyond annotations: the tool is scoped to the active Space, and space_id overrides that binding for this one call without changing the session. 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?

Two sentences with zero waste. The first front-loads exactly what is returned, and the second immediately covers the Space scoping and alternative.

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 tool with no output schema, the description adequately conveys the return values and the Space-scoping behavior. It leaves a minor gap: with zero required parameters, it does not clarify how optional business_id behaves (e.g., omitted means all businesses or a default).

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

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

Schema coverage is 100%, so both parameters are fully documented. The description reinforces the space_id override semantics (matching the schema) but adds no new meaning for business_id, so baseline 3 applies when the schema does the heavy lifting.

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

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

The description states exactly what the tool reports: per-business competitor tracking limits, current tracked count, and the monthly ad library lookup allowance. It distinguishes itself from siblings like get_competitor and list_competitors by focusing on plan quotas/allowances rather than entity data, though it doesn't use an explicit verb.

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 explains Space scoping and explicitly names set_active_space as the alternative for switching, plus the space_id override for a single call. It does not say when to prefer this over adjacent read tools such as get_competitor_coverage or account_summary, but provides clear context for the Space dimension.

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

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

Annotations only declare readOnlyHint; the description adds non-obvious behavior — a platform with no auction data explains why rather than returning zeros, preventing an agent from misreading empty results as a competitive gap. It also discloses Space scoping and the per-call override. It does not cover data freshness or sync prerequisites.

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

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

Front-loaded with the resource and its metric list, then behavior, then scoping. The metric enumeration is dense but each item tells the agent what it will get; no filler sentences.

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

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

With no output schema, the description carries the burden of describing returns and does so by naming the metric groups. The zero-result behavior note is a meaningful completeness win. Remaining gap is how to obtain a valid competitor_id and whether data depends on a recent sync.

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

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

Schema coverage is 100%, so both parameters are documented in structured fields and the baseline applies. The description's space_id override sentence mostly restates the schema, and it adds nothing about competitor_id — e.g., that IDs come from list_competitors.

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

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

States a specific verb+resource (competitor auction data) and enumerates the exact metrics returned: overlap rate, outranking share, top-of-page rates, 13-week trend, impression share lost to rank. This clearly separates it from sibling read tools like get_competitor_coverage or get_competitor_offers, though it never names those siblings explicitly.

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

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

Imparts clear context (auction/competitive overlap per platform) and gives actionable scoping guidance, naming set_active_space for switching and explaining the space_id one-call override. It stops short of stating when to prefer this over adjacent competitor tools such as get_competitor_coverage.

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=true already declares the safety profile, so the description's added value is the Space-scoping behavior: reads are confined to the active Space and space_id overrides for a single call only. It adds nothing about freshness/latency of coverage data, permissions, or result shape beyond the conceptual list of what the tool reports.

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, with the core 'what data' clause front-loaded and the scoping caveat placed second. The first sentence is a dense three-part list, which is efficient but slightly hard to parse on a first read.

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

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

For a two-parameter read-only lookup with no output schema, the description effectively pre-describes the return content by naming the three coverage questions it answers. The only real gap is the opaque business_id, which matters because coverage is presumably per-business.

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

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

Schema coverage is 100%, so both parameters are documented structurally and space_id even explains the override semantics. The description only restates the space_id override and says nothing about business_id beyond what the schema offers ('The business id.'), leaving unclear whether that is the advertiser's business or a competitor's.

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 enumerates the exact content returned: which public ad library covers each connected platform by region, which platforms lack a library, and the source of auction data. That is a specific resource shape distinguishable from siblings like get_competitor_allowance or get_competitor_auction. It never explicitly contrasts itself with those siblings, which keeps it off a 5.

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

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

It gives a real usage rule for Space scoping and points to set_active_space as the switching mechanism, plus the space_id one-call override. It never says when to call this versus the other competitor data tools (get_competitor_auction, find_competitor_library_accounts), so selection between siblings is left to inference.

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

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

Annotations already declare readOnlyHint=true, so safety is covered. The description adds meaningful context beyond that: the data provenance warning ('shows what a competitor published, never what worked') and the fact that offers are returned quoted with change history. It doesn't cover pagination or volume limits, keeping it below 5.

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

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

Three tight sentences, front-loaded with what is returned before the provenance caveat and Space scoping. No filler, though the Space 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?

No output schema exists, and the description explicitly characterizes the return shape (quoted offer elements, headline offer, change history), so an agent knows what it gets. With annotations covering safety and full schema coverage, nothing essential is missing.

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

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

Schema coverage is 100%, so both parameters are already documented, including the space_id override semantics. The description echoes the Space behavior but adds no new detail on competitor_id. Baseline 3 applies.

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

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

States the resource precisely - offer elements (prices, discounts, trials, guarantees, deadlines) extracted from a competitor's active ads, with quotes and the headline offer. The caveat that library data shows what was published, not what worked helps distinguish it from performance-oriented siblings like get_performance_stats. However, it never names list_competitor_ads, leaving the closest sibling undifferentiated.

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 Space scoping guidance is clear (uses active Space, switch via set_active_space, or override with space_id). But there is no explicit when-to-use vs list_competitor_ads or get_competitor, and the 'never what worked' note is interpretive caution rather than selection 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?

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?

Annotations already mark this as readOnlyHint=true, and the description consistently describes a read operation. It adds useful behavioral context beyond the annotation: the result scope (active Space), the override behavior via space_id, and the return categories. No contradictions found, and it helps an agent know what to expect from the call.

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

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

Three sentences, each earning its place: the first states the core functionality and return content, the second gives the primary use case, and the third clarifies scoping and override behavior. Information is front-loaded and there is no filler.

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

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

The description covers the operation, return categories, filtering options, and active Space behavior, which is sufficient for a read-only tool with three optional parameters and no output schema. It doesn't specify exact response shape or limits for 'most recent uploads,' but it gives an agent enough to invoke it correctly.

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

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

Schema description coverage is 100%, so the schema already documents all three parameters well. The description reinforces the campaign_id filter and space_id override semantics, but does not add substantial meaning beyond what the schema already states. Baseline 3 is appropriate here.

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 ('Return offline-conversion upload status for the active Space') and enumerates the exact data returned: total count, last upload time, total value, and most recent uploads. This clearly distinguishes it from sibling tools like get_conversion_report or get_conversion_health, which serve different purposes.

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 when to use the tool: 'The cheapest way to verify that the offline conversions you report are actually landing.' It also gives practical scoping guidance, referencing set_active_space and space_id override. It does not explicitly exclude alternatives like get_conversion_report, but the purpose and cost framing provide sufficient 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?

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?

readOnlyHint already covers the safety profile, so the description's 'Read-only' restates it, but it adds genuinely new behavior: the 404 NO_BRIEFING empty-state signal and the Space-scoping/override semantics. It stops short of saying how a stale briefing is represented or whether the response is cached.

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

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

One dense paragraph, front-loaded with what is returned before the edge cases and scoping rules. Every clause carries information, though the 'Read-only' sentence is redundant with the annotation and could be dropped.

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

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

With no output schema, the description compensates by describing the return payload's three components and the error case, which is what an agent needs. The only missing piece is disambiguation from get_answer_brief in a very large sibling set.

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

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

Schema description coverage is 100% and the single space_id parameter is fully documented there, including the pattern and session-binding behavior. The description's 'pass space_id to override for this one call' merely echoes the schema, so baseline 3 is right.

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

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

The description names a specific resource (the growth manager's latest briefing) and enumerates its contents — covering period, text, and prepared changes with status. That is far more concrete than the title. It does not, however, distinguish itself from the similarly named sibling get_answer_brief, which an agent could easily confuse with it.

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

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

It gives clear usage context: read the briefing for the active Space, use set_active_space to switch, or pass space_id for a one-off override, and expect 404 NO_BRIEFING when nothing exists. The one gap is that no alternative tool is excluded — get_answer_brief is never mentioned as the thing to use for a different kind of brief.

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 readOnlyHint, the description discloses important behavior: provisional readings are never written to the ad and are not counted in angle results until a person confirms them. It also explains the confirmation workflow and Space scoping, which are meaningful operational details for an agent.

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 behavior, followed by a clear user-facing instruction and then scope guidance. Every sentence earns its place, and the parenthetical clarifies rather than bloats.

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 tool with two parameters and no output schema, the description gives enough context about the grouped return categories and the confirmation workflow. It could say more about pagination or exact response shape, but nothing critical is missing 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?

Schema description coverage is 100%, so both parameters are already documented in the schema. The description reinforces that business_id selects the business and that space_id overrides the active Space for one call, but adds little syntax or semantic detail beyond the schema.

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

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

The description clearly identifies the resource and result: active ads grouped by the angle each argues, including confirmed, provisional, and unreadable readings. It is specific enough for an agent to distinguish this from a plain ad list, though it does not explicitly name a sibling tool or state the verb as directly as it could.

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

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

It gives a clear workflow instruction: show readings to the user before confirming any. It also explains Space scoping and points to set_active_space or the space_id override. It does not explicitly state when to prefer this over list_ads or get_ad, but the intended context is clear.

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