AffiliateSpy

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

Annotations already declare write, non-destructive, non-idempotent, and closed-world behavior. The description adds specific behavioral context beyond that: the next scan mines affiliates deep, the exact error conditions too_many and already_tracked, and the undo tool remove_competitor.

Agents need to know what a tool does to the 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 purpose, then constraints, then undo. 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 write tool with full schema coverage and annotations covering its safety profile, the description supplies error codes, scan impact, and undo path. Nothing needed to call it correctly is missing.

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

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

Schema description coverage is 100%, so all four parameters are fully documented in the schema. The description adds only 'by domain or URL' for the required domain, which matches schema text and provides no additional syntax or format detail.

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

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

Clearly states the verb (add), resource (competitor), and method (by domain or URL). It does not explicitly contrast with the sibling add_suggested_competitor, so sibling differentiation is implied rather than stated.

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

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

Gives clear context for use: same rules as the Competitors page, plan cap (too_many), duplicate brand (already_tracked), and the undo path via remove_competitor. It does not explicitly say when to choose this over add_suggested_competitor, but the constraints and reversibility guidance are 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?

With annotations only declaring destructive/not-idempotent/non-read-only, the description carries strong extra context: nothing sends until launch in draft, active/paused campaigns enrol immediately, only REVEALED-email creators qualify, others return as excluded, dm_only have no email, and the approval_token guard returns an approval_required error. This is exactly the behavioral depth annotations cannot 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?

Dense but front-loaded with the verb and resource, then ordered by behavioural importance (draft, enrolment, eligibility, guard). The closing 'dashboard guardrail' sentence earns its place as a scope statement, though the prose is heavier than strictly necessary.

Shorter descriptions cost fewer tokens and are easier for agents to parse. 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, non-idempotent, destructive mutation with no output schema, the description covers the mutation semantics, eligibility filtering, error/approval flow, and downstream scheduling effects. Nothing an agent needs to call it correctly is missing.

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

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

Schema coverage is 100% so the baseline is 3, but the description adds real meaning: creator_ids eligibility rules (revealed email, no opt-out/bounce) and the approval_token round-trip (error response, then re-call with token). It goes beyond the schema's one-line parameter docs without restating them.

Input schemas describe structure but not intent. Descriptions should explain 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 creators to a campaign') and immediately distinguishes the operation from a plain write by explaining draft-growth vs active/paused enrolment. An agent can tell this apart from siblings like add_websites_to_campaign or launch_campaign 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 anchors the tool to the dashboard 'Add to campaign' action, spells out when it applies (draft vs active/paused), and gives a real exclusion: 'Campaigns written for websites refuse creators.' Alternatives and preconditions are 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 the safety profile (readOnlyHint=false, destructiveHint=false, idempotentHint=false), and the description adds real context beyond them: a hard cap of 30 keywords on a project, priority ordering in sweeps, and the restore path from remove_keyword. It stops short of covering duplicate handling or how the 'confirm' guard interacts with adding.

Agents need to know what a tool does to the 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 action, followed by behavioral detail and the undo routing. No filler, though the undo sentence could be trimmed without losing meaning.

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

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

For a 4-param mutation tool with no output schema and annotations covering safety, the description supplies the missing behavioral facts (cap, sweep priority, undo path). Gaps remain around duplicate keywords and the confirm-guard flow, but the essentials for correct invocation are present.

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

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

With 75% schema coverage the schema carries most of the load, but the description adds genuinely new meaning: the 30-keyword cap constrains the required keyword parameter, and it explains that the nested restore object replays remove_keyword's undo (position plus whether it was custom) — details the schema descriptions don't fully spell out.

Input schemas describe structure but not intent. Descriptions should explain 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: tracking a search keyword on a project. The limit (30 at most) and the routing note to remove_keyword's undo.restore help distinguish it from list_keywords/remove_keyword, though it doesn't explicitly name those siblings as alternatives.

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

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

Gives one concrete usage rule — pass undo.restore to reverse remove_keyword — and implies the tool's role ('searched first by every sweep'). But it never states when to add a keyword versus using add_suggested_competitor or list_keywords, and gives no prerequisites beyond the implicit 30-keyword cap.

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

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

Annotations already declare readOnlyHint=false, destructiveHint=false, idempotentHint=false, so the write/safety profile is covered. The description adds useful scope behavior ('seeds belong to the account, not one project'), but says nothing about reversibility, the confirm guard referenced in the schema, or what happens on a duplicate seed.

Agents need to know what a tool does to the 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 with zero waste: purpose first, then the account-scope constraint, then the sibling routing. Nothing is buried or repeated.

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

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

No output schema exists, so the description must stand alone, and it covers purpose, scope, and alternative adequately for a simple add operation. It stops short of describing duplicate handling or when the confirm flag is expected, which are the only meaningful gaps.

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

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

Schema description coverage is 100%, so all three parameters (app_id, address, confirm) are already documented in the schema itself. The description adds no parameter-level detail beyond the Gmail-vs-manual distinction, so the baseline 3 is appropriate.

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

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

States a specific verb+resource ('Add a seed inbox') and immediately scopes it to manual-check inbox placement tests (Outlook, Yahoo), which cleanly separates it from the Gmail/automatic sibling. An agent can identify this tool without opening any schema.

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

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

Explicitly routes to the alternative: 'For a Gmail seed whose results are read automatically, use get_seed_connect_link instead.' The condition that selects this tool (results the owner checks by hand) and the condition that selects the sibling are both stated.

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

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

Annotations cover the safety profile (readOnlyHint=false, destructiveHint=false, idempotentHint=false), and the description adds genuinely non-obvious behavior: the suggestion is 'mined deep on the next scan' (a deferred effect, not immediate), the cap triggers a swap mode, and both operations are reversible. It also explains confirm's role via the secondary path. Minor gap: 'as the rail's Add/Swap does' is UI jargon an agent cannot resolve, and the return/receipt format is unspecified.

Agents need to know what a tool does to the 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 dense sentences, reasonably front-loaded with the primary action before the cap/swap and undo branches. The 'rail's Add/Swap' analogies and 'mined deep' phrasing consume space without adding agent-resolvable meaning.

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

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

For a mutation tool with no output schema and full schema coverage, the description supplies the missing pieces an agent needs: source of input, cap handling, and undo paths. Only the post-call result/pagination behavior is not covered, which is a minor omission.

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

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

Schema description coverage is 100%, so the baseline is 3; the description adds meaning by tying swap_out_id to the 'at the cap' condition and clarifying it is usually swap_out.id from get_competitor_suggestions. root/app_id/confirm are left to the schema, which already documents them well.

Input schemas describe structure but not intent. Descriptions should explain 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 ('Add a suggestion ... to the list') and identifies the source tool (get_competitor_suggestions) versus the sibling add_competitor, which adds competitors directly. An agent can tell what this does and where the input comes from 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?

Explicit conditions: use swap_out_id when at the cap, undo an add with remove_competitor, undo a swap with restore_competitor. It names the alternatives and the trigger for each, leaving little 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?

Far beyond the annotations (destructive/openWorld/idempotent hints), it discloses the full enrol-gate eligibility rules, the skip-reason counting behavior, the approval_required two-call flow with the exact error payload shape, and that dashboard guardrails still apply. This is unusually rich behavioral disclosure for a mutation tool.

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

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

Purpose and the enrol-gate mechanics are front-loaded, and most sentences carry distinct facts. It is a dense paragraph that could be broken up, but there is little outright waste.

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

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

With no output schema, the description supplies return-side context (counts explaining skips, the approval_required error object), the gating semantics, and scope limits, so an agent has everything needed to call it and interpret the result.

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

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

Schema coverage is already 100%, so the baseline is 3; the description adds genuine value by explaining the approval_token retry flow that the schema only describes statically ('call again with the token'). It adds little about site_ids/campaign_id beyond what the schema already documents.

Input schemas describe structure but not intent. Descriptions should explain 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 sites to a campaign') and anchors it to a familiar UI action ('Add to campaign on the Websites tab'). It is clearly distinguishable from the sibling add_creators_to_campaign, which targets a different entity type.

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

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

Gives strong conditional context: draft campaigns only grow the audience while active/paused campaigns enrol immediately through the enrol gate, and creator-type campaigns refuse websites. It does not explicitly name an alternative tool or a when-not-to-use condition, which keeps it 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?

Goes well beyond the annotations (destructiveHint=true, idempotentHint=false) by disclosing the metered contact reveal, that edits require a fresh approval, that remove_ids permanently flags sites so autopilot never re-proposes them, and that missing approval_token yields a structured error plus token. It also ties the guardrails to the dashboard's approve button, defining the blast radius.

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

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

Front-loads the core action ('Approve a queued autopilot action and EXECUTE it') and then details side effects, edits, and the token guard in a logical order. It is dense and long, but nearly every clause carries operational information; the enumerated action-type list is the only mildly expendable part.

Shorter descriptions cost fewer tokens and are easier for agents to parse. 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, non-idempotent mutation with no output schema, the description covers the trigger (queue ids), the guard flow (token), the side effects per action type, and the edit semantics. An agent has enough to call it correctly without opening another 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, but the description adds real meaning: body replaces the drafted text, remove_ids drops sites and flags them, and approval_token is explicitly framed as coming from a prior approval_required response after user confirmation. That is value beyond the field descriptions.

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

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

States a specific verb ('Approve ... and EXECUTE') plus the resource (a queued autopilot action) and enumerates the concrete action types it can trigger, so the agent immediately understands what happens. The name alone would be ambiguous against hold/reject/get siblings, but the description removes that 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?

Gives clear context (action ids come from get_autopilot's queue) and the exact two-step token flow to use when the tool returns approval_required. It does not explicitly contrast with hold_autopilot_action or reject_autopilot_action, so the when-not guidance 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 establish readOnly/idempotent/non-destructive, and the description adds genuinely new behavioral content: the hint vocabulary and the up-to-3 cap, which tells the agent what to expect back. The standalone 'Read-only' sentence is redundant with annotations rather than additive.

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

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

A single dense paragraph, but front-loaded with the purpose and the hint list, then the input-format caveat. The redundant 'Read-only' tail is the only dispensable element, so it is efficient without being minimal.

Shorter descriptions cost fewer tokens and are easier for agents to parse. 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 compensates by enumerating the possible hints and the cap, plus the judgment basis and required input form. An agent can call this and interpret the result without guessing, though the exact response shape is still only described informally.

Complex tools with many parameters or behaviors need more documentation. 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: campaign_id selects the campaign offer as the judgment basis and its absence falls back to program + autopilot offer, and body must be the rendered email rather than raw tokens.

Input schemas describe structure but not intent. Descriptions should explain 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 (quality hints / check) on a specific resource (an email draft) and grounds it in the familiar dashboard editor behavior. It is clearly distinguishable from siblings like preview_campaign_step, which it names as the upstream supplier of the input.

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

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

Gives concrete usage context: pass the rendered email from preview_campaign_step, not {{tokens}}, and explains the fallback judgment basis when campaign_id is absent. It lacks an explicit 'when not to use' clause, so it falls short of a 5.

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

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

Annotations already indicate this is not read-only or destructive, but the description adds the critical behavioral guarantee 'DRAFT ONLY, this tool cannot launch, enroll, or send'. This clarifies that no side effects beyond draft creation occur, which is valuable context beyond the annotations. 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?

Three concise sentences: purpose, limitation, and follow-up action. The draft-only constraint is front-loaded immediately after the purpose, and the dashboard link is provided without extra fluff. Every sentence earns its place 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 draft-creation tool with no output schema, the description covers the essential purpose, input methods, and the critical limitation. However, it does not indicate what the tool returns (e.g., campaign id or confirmation), which an agent might need. The guard behavior for the confirm parameter is only in the schema, not the description. These are minor gaps given the otherwise clear usage.

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

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

Schema description coverage is 83%, and the schema itself documents most parameters (offer, confirm, use_saved, creator_ids, followup_gaps_days). The description adds little beyond schema, mostly reinforcing the use_saved/creator_ids relationship and mentioning the default 4-step sequence (not a parameter). The name parameter lacks schema description but is self-explanatory. With high schema coverage, a 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 clearly states the verb 'create' and the resource 'DRAFT outreach campaign', specifies the input source ('creator ids or your saved list') and the default 4-step sequence. It explicitly distinguishes this from launching by stating 'DRAFT ONLY, this tool cannot launch, enroll, or send', which sets it apart from sibling tools like launch_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 gives clear when-not guidance: it cannot launch, enroll, or send, and points to the dashboard for review and launch. It implies that launching is done elsewhere, but does not explicitly name the sibling tool launch_campaign. The audience selection guidance (creator ids vs saved list) is also provided, adding practical usage context.

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

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

Annotations already declare non-read-only, non-destructive, non-idempotent. The description adds genuinely useful behavior beyond them: one-deal-per-creator uniqueness and the upsert-like stage-move on an existing deal. It omits return shape and error 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?

Three short sentences, front-loaded with the core action, then the uniqueness rule, then the exclusion. Dense but no wasted words; slight compression makes the second sentence need 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?

With no output schema, the description could say what a successful call returns, but it fully covers the input routes and the create-vs-update behavior for an agent to act correctly. Minor gap in return-value disclosure.

Complex tools with many parameters or behaviors need more documentation. 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 stage, confirm, creator_id and enrollment_id with sources for each id. The description adds no syntax or format detail beyond that, so the baseline 3 applies.

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

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

The description names a specific verb and resource ('Put a creator in the pipeline') and clarifies the two input routes (creator id or inbox thread). The clarification that an existing deal causes a stage move slightly blurs the create-vs-update boundary, but it is still distinguishable from siblings like update_deal and move_deal_stage.

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

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

It gives clear context for when to use the tool and an explicit exclusion: website threads have no deals yet, so track a site by its status instead. It does not explicitly name update_deal or move_deal_stage as alternatives, which keeps it short of a 5.

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

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

Annotations only declare the basic non-read-only/non-destructive/non-idempotent profile; the description adds substantial behavioral detail beyond them: the copy must pass the same validation enrolment runs (no links, bare domains, stock phrases, unknown tokens, or empty offer) or nothing is created, and it explicitly states DRAFT ONLY with nothing enrolled or sent. This is meaningful, non-obvious behavior 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?

Front-loads the core action, then layers validation, tokens, and the draft/launch boundary in information-dense sentences with little waste. It is slightly long and packs several distinct topics, but each sentence carries actionable 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 an 11-parameter write tool with no output schema, the description covers the critical unknowns: draft-only semantics, validation gating, personalisation tokens, and the launch transition. It defers scheduling detail to the 91%-covered schema, which is reasonable, leaving only minor gaps.

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

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

Schema coverage is 91%, so the schema already documents nearly every parameter, making 3 the baseline. The description adds semantic value on tokens ({{greeting}}, {{opener}}, {{offer_pitch}}, etc.) and on the default-sequence-vs-steps behavior, but it does not explain the scheduling parameters (days, hour_from/hour_to, timezone, daily_limit, followup_gaps_days) 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?

States a specific verb and resource: 'Create a DRAFT campaign for sites from list_websites (one project)'. It scopes the resource (website campaigns, single project) and distinguishes itself from the generic draft creator by tying inputs to list_websites, so an agent can tell it apart from create_campaign_draft 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?

Gives clear context: use list_websites for site_ids, get_campaign and preview_campaign_step to inspect/render templates, and launch_campaign to actually start sending. It also clarifies the draft-vs-launch boundary. It does not explicitly contrast against the sibling create_campaign_draft, so it stops short of full alternative routing.

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

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

Annotations already flag destructiveHint=true, but the description adds substantial context beyond them: what is destroyed (lists, queued emails), what is preserved as contact history (enrolments, messages), that recipients cannot be re-emailed from scratch, that late replies still reach the Inbox, and that there is no undo. It also discloses the approval_token gate and the exact shape of the approval_required response.

Agents need to know what a tool does to the 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 core action and its consequences, and the approval mechanism is stated before the closing scope note. Slightly redundant phrasing ('as the dashboard does' / 'Every dashboard guardrail still applies') costs a little, but nearly every sentence carries information.

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

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

For a destructive mutation with no output schema, the description covers the full picture: irreversibility, data retention, the approval handshake, and the error payload an agent must parse. Nothing needed to call it correctly is missing.

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

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

Schema coverage is 100%, so the baseline is 3, but the description adds real meaning beyond the schema by explaining the approval_token lifecycle: the first call without it returns {error, approval_token, summary}, and the second call supplies the token after user confirmation. That is operational semantics the schema alone does not convey.

Input schemas describe structure but not intent. Descriptions should explain 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 ('Delete a campaign') and immediately distinguishes the operation from sibling lifecycle tools by describing its effects: it leaves every list and queued emails stop. An agent can tell this apart from pause_campaign/resume_campaign/duplicate_campaign 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?

Gives clear context for when this is appropriate ('exactly what a user clicking the dashboard could do, no more') and explains the guarded two-step confirmation flow. It stops short of explicitly routing the agent to an alternative such as pause_campaign for a reversible stop, so the when-not guidance is implied rather than stated.

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

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

Annotations declare readOnlyHint=false, destructiveHint=false and idempotentHint=false, so the safety profile is largely covered. The description adds genuine extra context the annotations lack: the dismissal is persistent ('for good' — later scans keep the choice) and is reversible via undo, which is the key behavior an agent needs.

Agents need to know what a tool does to the 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, front-loaded sentences with zero filler. The persistence trait comes first and the reversal path second, which is the right ordering for an agent deciding whether to call it.

Shorter descriptions cost fewer tokens and are easier for agents to parse. 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 four-parameter mutation with full schema coverage, no output schema and annotations covering safety, the description covers what the tool does and its persistence/reversal semantics. It omits the confirm-guard interaction, but that parameter is fully explained in the schema, so the 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 description coverage is 100%, so all four parameters (root, undo, app_id, confirm) are already documented in the schema. The description restates the undo semantics ('puts a dismissed suggestion back on the rail') but adds no syntax or format detail beyond what the schema provides, 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?

States a concrete verb and resource ('Hide a suggestion for good'), making the mutation unambiguous. It implicitly distinguishes itself from the read-side siblings like get_competitor_suggestions, but never names an alternative, so it stops short of a 5.

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

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

The description explains the undo branch ('undo: true puts a dismissed suggestion back on the rail'), which tells the agent when to use that mode. However, it gives no guidance on when to prefer dismiss vs. add_suggested_competitor or get_competitor_suggestions, leaving the primary usage context implied.

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

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

Annotations already declare destructive=false and readOnly=false. The description adds real behavioral context beyond them: what is copied (audience, sequence, settings), what is omitted (no enrolments), and the safety property that nothing sends until launch. It does not explain the confirm guard or idempotency, keeping it short of a 5.

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

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

Two tight sentences, front-loaded with the verb and result, with the no-send guarantee as supporting context. 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 two-parameter mutation with no output schema and full annotation coverage, the description covers what is created and the safety profile adequately. It leaves the return value (presumably the new draft's id) unstated, a minor gap since no output schema exists.

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

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

Schema description coverage is 100% and both params (campaign_id, confirm) are self-documented, so the baseline is 3. The description adds no parameter syntax or behavior beyond what the schema already provides.

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

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

States a specific verb (copy/duplicate) and resource (campaign) and immediately scopes the result as a new DRAFT with same audience/sequence/settings. An agent can distinguish it from create_campaign_draft, launch_campaign, and update_campaign_settings 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?

The 'Nothing is sent until the copy is launched' clause implies the draft-state context and contrasts implicitly with launch_campaign, but no sibling is named and there is no explicit when-to-use / when-not-to-use guidance. Usage is inferable but not spelled out.

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

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

Annotations already indicate read-only and idempotent behavior, and the description adds valuable non-obvious details: the paid feature/subscription gate and the email privacy rule ('Emails appear ONLY for creators you have revealed'). These are behaviorally significant and not inferable from the annotations. No contradiction exists.

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

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

Three sentences, each carrying distinct information: output format and filter equivalence, subscription gating, and email redaction. It is front-loaded with the core purpose and avoids 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 an export tool with no required parameters and a high-coverage schema, the description covers the important non-schema aspects: subscription requirement and data visibility restrictions. The main gap is that it does not describe how the CSV is delivered (e.g., file download vs URL), and there is no output schema to fill that in, but this is not critical 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 86%, so individual parameters are already documented. The description's main added semantic is 'same filters as list_creators', which helps conceptually but does not explain any individual parameter. It clarifies that 'has_contact' values are hidden until revealed, but that is behavioral rather than semantic detail. Baseline 3 is appropriate.

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

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

The description states the deliverable clearly: 'CSV of your creator list', which distinguishes it from list_creators by output format. It also references the sibling list_creators to clarify that the same filtering applies caeteris. The operation is slightly implicit, relying on the title for the 'Export' verb, but the purpose is unambiguous.

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

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

The description says 'same filters as list_creators', connecting it to a known sibling and making the output format the key differentiating factor. It also provides important selection context: 'requires an active subscription, same gate as the dashboard export'. It lacks an explicit 'when not to use' statement, but the context is clear enough.

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

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

Goes well beyond the annotations: it discloses the free-then-one-paid-lookup flow, the monthly finder budget gate, one-site-at-a-time ~4-minute execution, 'not_started' for unreached sites, that nothing is sent, and the exact guarded approval flow including the {error:'approval_required', approval_token, summary} shape and the re-call requirement.

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

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

Dense and front-loaded, with the core action stated first and guardrails after. Given the tool's complexity the length is largely justified, though the closing 'Every dashboard guardrail still applies... no more' restates earlier points and is mildly redundant.

Shorter descriptions cost fewer tokens and are easier for agents to parse. 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 and does so: it explains results (addresses and contact name saved on the site), partial-completion semantics (not_started), spend limits, and the approval handshake error payload. Nothing essential for correct invocation is missing.

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

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

Schema coverage is 100%, so the baseline is 3, but the description adds real meaning about the approval_token round-trip and the site_ids skip/budget behavior that the schema alone doesn't convey. It doesn't add new detail on site_ids beyond the schema's 'up to 25'.

Input schemas describe structure but not intent. Descriptions should explain 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+scope: 'Find a contact email for up to 25 sites,' and anchors it to a known UI action ('as the Websites Find email button does'). It is clearly distinguishable from siblings like set_website_contact (manual entry), reveal_contact, and list_websites.

Agents choose between tools based on descriptions. A clear purpose with a specific verb 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 strong context: when contacts already exist the site is skipped, the free chain runs before the paid lookup, and budget must have room. It stops short of naming sibling alternatives (e.g., reveal_contact or set_website_contact) for when the agent should prefer manual entry instead.

Agents often have multiple tools that could apply. Explicit usage 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 it readOnly, idempotent, and non-destructive. The description adds valuable behavioral context beyond that: it specifies the return content (plan name, caps, contact reveal usage with UTC reset on the 1st, tracked app usage vs cap). This tells the agent exactly what to expect without any side effects. 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?

A single sentence that front-loads the purpose ('Your AffiliateSpy plan and usage') and packs in all relevant details without redundancy. Every clause earns its place, and it is immediately scannable.

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

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

For a parameterless read-only tool with no output schema, the description fully covers what the agent needs: it enumerates the returned fields and even notes the reset schedule. There is no missing information that would hinder correct invocation or interpretation of the response.

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

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

The tool has zero parameters, so the baseline is 4 per the rubric. There is nothing to explain beyond the schema, which is already empty. The description doesn't need to add parameter meaning, and it doesn't. This 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 resource (AffiliateSpy account) and the specific data returned: plan name, caps, contact reveal usage with reset schedule, and tracked app usage. This distinguishes it from sibling get_* tools, which all target different resources (campaign, creator, thread, etc.). No ambiguity.

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

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

While no explicit 'use when' guidance is provided, the description makes it self-evident that this is the tool to check plan limits and quota usage. It names the exact metrics (contact reveals used/left, tracked apps used vs cap), which implies it should be consulted before quota-consuming operations. It doesn't state exclusions or alternatives, but there is no competing sibling for account-level info, so this is adequate.

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

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

Annotations already declare readOnly/idempotent/non-destructive, so the redundant 'Read-only' adds little. However, the description goes well beyond structured data by decoding domain semantics: what held_by_breaker means, how autopilot_status/running_for relate, and what paused_reason governs.

Agents need to know what a tool does to the 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 core purpose and free of filler, but it is one very long run-on sentence whose parenthetical asides make it dense. Every clause carries field meaning, so size is justified even if readability suffers.

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

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

With no output schema, the description carries the burden of explaining returns and does so for the major fields (status, cap, waiting-on, queue, recent activity), giving an agent enough to interpret results. Minor return fields likely remain unexplained.

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

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

Single optional parameter with 100% schema description coverage, so the schema already documents app_id and its 'omit for the running project' default. The description's 'default: the project it runs for' merely echoes the schema, adding no syntax or format detail.

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

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

States a specific verb+resource (get the Discovery Autopilot state for a project) and enumerates what 'state' comprises (status, cap usage, waiting-on, approval queue, recent activity). It is clearly a getter contrasted with the set_autopilot sibling, though it never explicitly names that contrast.

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

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

Usage is implied rather than stated. The clause about the default project and the note that set_autopilot clears held_by_breaker give context, but there is no explicit 'use this when...' guidance or named alternative for retrieving different state.

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

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

Annotations already declare readOnly/idempotent/non-destructive, so the safety profile is covered and the trailing 'Read-only' is partly redundant. The description still adds genuine value by disclosing the response payload shape and the non-obvious flag semantic 'selected:false means dropped'.

Agents need to know what a tool does to the 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 core purpose in the first clause, then a dense but information-rich enumeration of payload fields. It is one long run-on sentence, but nearly every clause earns its place by describing a distinct part of the returned record.

Shorter descriptions cost fewer tokens and are easier for agents to parse. 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 correctly carries the burden of describing return values and does so thoroughly (type, lane, status, error, draft, thread, triage/QA flags, website batch details). The only gap is usage routing relative to approve/hold/reject siblings that share the same id.

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

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

Schema description coverage is 100% for the single action_id parameter, and the schema already notes the id comes from get_autopilot's queue. The description adds nothing beyond the schema for parameters, so the baseline 3 applies.

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

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

States a specific verb and resource — fetching ONE autopilot action in full — and explicitly distinguishes it from the queue-level sibling by naming the 'approval card' view and enumerating the fields returned. An agent can tell this apart from get_autopilot without opening either 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?

Usage is implied: it retrieves a single item, and the schema notes the id comes from get_autopilot's queue. However, there is no explicit when-to-use/when-not guidance and no mention of the approve/hold/reject siblings that also act on an action_id.

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

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

Annotations already declare readOnlyHint=true and destructiveHint=false, so the safety profile is covered. The description adds value by specifying the exact content of the response, which goes beyond the annotations. It does not mention auth requirements or rate limits, but these are not critical for a read-only get.

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

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

The description is a single, efficient sentence that lists the key data components. It is front-loaded with the resource type and immediately states what is included. 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 simple read-only get with one parameter and no output schema, the description adequately conveys what is returned. The annotations cover safety, and the listed components give a clear picture of the response. It could optionally describe error cases or format, but that is not essential 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 0%, so the description must compensate. However, the description does not mention campaign_id at all. While the parameter name and tool name make its purpose obvious, the description adds no meaning beyond the schema. It only describes the output, not the input.

Input schemas describe structure but not intent. Descriptions should explain 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 resource ('One campaign') and enumerates the specific data returned: settings, sequence templates, enrollment rows, and latest reply previews. This distinguishes it from list_campaigns (which lists many) and other get_* tools like get_creator or get_thread.

Agents choose between tools based on descriptions. A clear purpose with a specific verb 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 context is clear: use this when you have a campaign_id and need detailed information about that single campaign. It does not explicitly mention alternatives or exclusions, but the sibling list makes the distinction obvious. No exclusions are needed for a straightforward get operation.

Agents often have multiple tools that could apply. Explicit usage 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 annotations, it discloses that the user performs payment in the browser, that an active subscription is switched in place and prorated, and that access is only granted via the payment webhook. This materially changes how an agent should handle the returned URL and follow-up.

Agents need to know what a tool does to the 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 dense sentences with the primary purpose front-loaded. Every sentence carries operational information: what is returned, how the user pays, what happens on an existing subscription, and what to call next.

Shorter descriptions cost fewer tokens and are easier for agents to parse. 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 return variants are described explicitly, the payment flow is specified, and the follow-up call to get_account is provided. With no output schema, this description gives an agent enough behavioral context to select and 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 covers all three parameters, so the baseline is 3. The description adds useful pricing and billing-period context for plan and interval, although confirm is not mentioned in the description; the schema covers its 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 opens with a specific verb and resource: it returns a Stripe Checkout URL for a named plan. It also gives concrete pricing and the active-subscription alternative (settings URL), so there is no ambiguity about what this tool produces.

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

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

It gives clear context: the user opens the URL and pays, the agent must never enter payment details, and after payment the agent should call get_account. It does not explicitly state when not to use the tool or compare it to alternatives, but the workflow guidance 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 cover readOnly/idempotent/destructive, but the description adds real behavioral context: the 12-item cap, ranking order, the evidence categories behind each suggestion, and the precise semantics of swap_out (the mined competitor with fewest receipt sites). It does not mention pagination or auth, but the cap and swap semantics are non-obvious and usefully disclosed.

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

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

It is a single front-loaded sentence that starts with the resource, which is good. However it is a run-on packed with six enumerated 'why' examples and parenthetical detail that is heavier than needed for tool selection.

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

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

With no output schema, the description carries the return-value burden and does so well, explaining the suggested brands, their rationale fields, and swap_out. It is largely complete for a read-only, single-param tool, missing only explicit routing to the add/dismiss sibling tools.

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

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

Only one parameter (app_id) exists and the schema already documents it at 100% coverage, including the 'omit to use most recent project' behavior. The description adds nothing about the parameter, so the baseline of 3 applies.

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

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

The description concretely states what the tool returns: up to 12 mined brands not on the competitors list, ranked best-first, with the 'why' signals and a swap_out target. This distinguishes it from list_competitors and get_partners, 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?

There is no explicit statement of when to call this versus list_competitors, add_suggested_competitor, or dismiss_competitor_suggestion. The 'at the cap' swap_out detail implies a scenario, but the agent must infer the workflow and follow-up actions.

Agents often have multiple tools that could apply. Explicit usage 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, idempotentHint, and destructiveHint, covering safety. The description adds meaningful behavioral nuance by stating that contact value stays hidden unless already revealed, which is a non-obvious access-control behavior an agent needs to know.

Agents need to know what a tool does to the 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 one tight sentence that front-loads the main purpose, uses a colon to introduce the content categories, and ends with the contact-visibility caveat. Every clause earns its place and there is no redundant wording.

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

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

Even without an output schema, the description names the major response categories and the one conditional behavior that affects returned data. For a simple read-only detail tool with a single required parameter, this is enough for an agent to select and 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?

The only parameter, creator_id, is fully documented in the schema with a description pointing to list_creators as the source. The tool description adds no further parameter-level meaning, so the schema already carries this 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 opens with 'Full detail for one creator' and then enumerates the specific data categories returned, making the tool's purpose explicit. It is clearly distinguishable from list_creators and other sibling tools because it targets a single creator's full record rather than a collection or action.

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

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

The description clearly implies this is the detail-fetch tool for one creator, and the schema's parameter description ('An id from list_creators') reinforces the expected workflow of listing creators first. It does not explicitly name alternative tools or state when not to use it, so it stops short of a 5.

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

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

Annotations already declare readOnlyHint=true, idempotentHint=true, destructiveHint=false and openWorldHint=false, so the safety profile is covered. The description adds genuine behavioral detail beyond that: warm-up caps of 10/20/30 a day for weeks 1-3 with 'established skips it', errors/warnings surfaced 'in plain words', whether the placement test covers the current template, and a gate verdict. It does not mention error conditions (e.g. unconfigured domain) or how stale the results may be.

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

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

The purpose is front-loaded ('The project's sending health'), but the entire body is one long run-on sentence with a nested parenthetical list that is hard to scan. Most of the bulk is return-value enumeration, which is legitimate compensation for the missing output schema, yet it is packaged in a form that is denser than it needs to be.

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

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

With no output schema, the description correctly carries the burden of describing what comes back, and it covers the major components (domain checks, warm-up, seeds, placement test, gate verdict) thoroughly. It omits how to force a fresh test or what happens when deliverability data does not yet exist, but for a single-optional-param read tool it is close to 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?

There is a single optional app_id parameter at 100% schema description coverage, so the schema already explains that it comes from list_apps and defaults to the most recently added project. The description adds nothing about the parameter. Per the rubric, high coverage with no added param info lands at 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 states a specific verb+resource (the project's sending health) and enumerates the exact scope: SPF/DKIM/DMARC/MX/MTA-STS checks, outreach domain, warm-up caps, seed inboxes, and inbox placement results. This lets an agent distinguish it from generic siblings like get_overview or get_project_settings. It never names a sibling explicitly, so it stops short of a 5.

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

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

There is no when-to-use or when-not-to-use guidance. The only contextual anchor is '(App settings, Sending)', which is a UI location, not a routing cue. Given siblings like run_inbox_test, refresh_inbox_test_results, and recheck_from_domain that mutate/refresh this same data, the absence of any 'use X to trigger a new test' guidance is a real gap.

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

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

Annotations already declare readOnlyHint=true, idempotent, non-destructive, so the safety profile is covered; the description adds real context beyond that: the link is consumed by a human in a browser, requires an AffiliateSpy session, routes through Google's consent screen, and the mailbox is linked to the project afterwards. It omits link expiry/reuse behavior, which keeps it from a 5.

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

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

Dense but waste-free: the core function and its human-in-the-browser constraint come first, the reconnect variant second, and the imperative warning last. Every clause carries information.

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

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

For a two-optional-param link generator with no output schema, the description covers what the link is, who uses it, and the reconnect path. Only the lifetime/reuse behavior of the returned link is left unstated, 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?

Schema coverage is 100%, so the baseline is 3, but the description adds genuine semantics for 'reconnect' — it means re-consenting an existing connected mailbox, with a concrete use case (granting read access) — and frames app_id implicitly as the target project.

Input schemas describe structure but not intent. Descriptions should explain 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 (getting a mailbox connect link) and precisely what the artifact is: a browser link a signed-in AffiliateSpy human opens to run Gmail through Google's consent screen. This clearly distinguishes it from siblings like get_seed_connect_link and get_checkout_link, which produce different link types.

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

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

Explains the operating condition well: a human must open it in a browser, use reconnect to re-consent an already-connected mailbox (e.g., to grant read access), and explicitly warns 'Do not open it yourself.' It does not name competing tools, but the usage context is unambiguous.

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

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

Annotations already declare readOnlyHint=true, idempotentHint=true, destructiveHint=false, openWorldHint=false, so the safety profile is fully covered. The description adds useful context: the JSON-style scoping paragraph indicates the return shape and that 'project' changes the view. No auth/permission requirements or rate limits are mentioned, so it's adequate but not rich.

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

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

The single-property description is a run-on sentence with comma-dangled list items and a sentence fragment ('project: the given ...'). It mixes return-value enumeration, parameter semantics and scope notes without clear sentence boundaries, making it effortful to parse. Not front-loaded on the primary 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?

Annotations cover safety and the input schema fully documents app_id, so no safety or parameter details are missing. However, with no output schema and a verbose, loosely structured description, an agent must parse the paragraph to infer the return structure. It's usable but not complete or crisp for a tool enumerating many mailbox fields.

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

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

Schema coverage is 100% for the single parameter: the input schema already documents app_id fully (UUID format, 'Project id from list_apps. Omit to use your most recently added project.'). The description adds the concept that 'project' returns the given or newest project's mailbox and From, but doesn't give syntax beyond what the schema says. Baseline 3 is appropriate.

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

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

States a specific resource (Gmail mailboxes) and enumerates the exact data returned: read access status, free mailbox flag, plan limit status, warm-up, aliases, and sending projects. It's a clear list/retrieve verb with a detailed resource. However, it doesn't explicitly distinguish itself from close siblings like get_mailbox_connect_link or list_apps, so it doesn't reach 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 a read/list use case and notes that connecting, disconnecting and revoking happen in the dashboard, which softly brackets its scope. But there is no explicit when-to-use, when-not-to-use, or routing to alternatives (e.g. get_mailbox_connect_link for authorization). The paragraph about 'project:' hints at an alternate view but doesn't state selection criteria.

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

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

Annotations already declare readOnlyHint, idempotentHint, destructiveHint=false and openWorldHint=false, so safety is covered and 'Read-only' at the end is largely redundant. The description nonetheless adds real behavioral context beyond the annotations: the null/empty-state behavior when no competitor program terms have been collected, which is the only place that is documented given there is no output schema. No auth or rate-limit detail, 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 in the first clause, and the following enumeration is dense but every item is a distinct return field rather than filler. The trailing 'Read-only' restates the readOnlyHint annotation and is the one line that does not earn its place, keeping it out of 5 territory.

Shorter descriptions cost fewer tokens and are easier for agents to parse. 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 full burden of describing what comes back, and it does so field by field, plus it documents the empty/null case and the precondition that competitor terms must have been discovered. Nothing an agent needs in order to call this 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?

There is exactly one parameter and schema description coverage is 100%, with the schema itself explaining 'Project id from list_apps. Omit to use your most recently added project.' The description adds no further meaning about app_id semantics or defaulting, so the baseline of 3 for high-coverage schemas 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 opening clause names a specific computed resource — the project's commission offer versus competitors' published programs — which is clearly distinct from sibling readers like list_competitors (raw competitor list) or get_program (own program). It then enumerates the return contents (rates, cookie windows, market median, higher-paying open prospect sites, terms chips, affiliate directories), so an agent can identify the tool without opening a schema. It stops short of explicitly naming the sibling it should be chosen over.

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

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

Usage is only implied: 'benchmark null when no competitor program terms were found yet' hints that competitor data must exist first, which is a useful precondition signal. But there is no explicit when-to-use/when-not, no mention of how this differs from list_competitors or get_program, and no guidance on cadence or freshness.

Agents often have multiple tools that could apply. Explicit usage 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, idempotentHint, and openWorldHint=false, so safety is covered. The description adds real behavioral context beyond that: the 7/30/90-day deltas are null until a daily snapshot that old exists, and it discloses the 7-day competitor site-gain data. 'Read-only' merely repeats 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?

One sentence, front-loaded with the resource and its contents, ending with the read-only marker. The long parenthetical metric list is dense but every item is informative, so little is wasted.

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

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

With no output schema, the description carries the return-value burden and does so by naming all metrics plus the null-snapshot caveat. It is largely complete, though the absence of any usage routing is 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% and the single app_id parameter is fully documented in the schema (including the 'omit to use most recent project' fallback). The description adds no parameter-level detail, so the baseline of 3 applies.

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

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

States a specific resource ('the project's Overview metrics') and enumerates the exact metrics returned, so an agent knows precisely what payload to expect. This clearly distinguishes it from sibling readers like get_account, get_program, or get_deliverability.

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

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

No guidance on when to prefer this over the many other read siblings (get_account, get_program, get_competitor_suggestions, etc.). The 'Read-only' tag and app_id behavior imply it's a safe lookup, but nothing routes the agent here versus an alternative view.

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

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

Annotations already establish readOnly/idempotent/non-destructive, so the bar is lower. The description adds useful behavioral detail beyond them: the returned fields (clicks, conversions, revenue, commission in cents) and 'counts covers every tab', which tells the agent counts are tab-independent. Doesn't address pagination 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?

Dense and front-loaded: the scope definition comes first, then tab semantics, then the read-only note. Every clause carries information, though the run-on construction packs three partner categories into one sentence, slightly at the cost of scannability.

Shorter descriptions cost fewer tokens and are easier for agents to parse. 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 compensates by naming the return fields and their units (cents) plus tab semantics. It covers the enum and the general shape of the response. Missing only pagination/limit behavior and the app_id defaulting nuance.

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

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

Schema coverage is 75%, so tab, limit, and app_id already carry descriptions. The description adds real meaning on the enum: it glosses 'nofollow' as sites linking without passing authority and clarifies 'counts covers every tab'. It says nothing about limit/offset, but those are schema-documented.

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

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

States a specific verb (get) and resource (partners), and crucially defines the composite scope: creators in live/paid deals, featuring sites, and the affiliate roster. This effectively distinguishes it from list_creators/list_deals/get_program without naming them. The generic verb 'get' and lack of sibling naming keep it from 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?

Usage is implied via 'as the Partners page shows it' and the tab breakdown, letting an agent infer this is the aggregate partners view. However, there is no explicit when-to-use statement, no exclusion, and no pointer to a sibling for a narrower need (e.g. per-creator or per-site lookups).

Agents often have multiple tools that could apply. Explicit usage 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, idempotentHint, destructiveHint=false and openWorldHint=false, so safety is covered. The description adds genuine behavior beyond them: sales stats are only present 'when a sync stored them', the last-error field is exposed, and connect/disconnect requires an API key and lives in the dashboard rather than here.

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

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

Front-loads the identity of the resource before the long field list, and every clause names a returned field rather than padding. The semicolon-chained enumeration is dense but each element earns its place since there is no output schema.

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

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

There is no output schema, so the description carries the full return-shape burden and does so comprehensively, including the conditional nature of the sales stats. The redirect for connect/disconnect closes the remaining gap, leaving nothing an agent needs 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?

Only one parameter and schema description coverage is 100% – the schema already documents app_id including the 'omit to use your most recently added project' default. The description adds no additional parameter meaning, so this is 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?

States a specific verb+resource (get the project's affiliate program connection) and enumerates exactly what it surfaces: provider, program id, status, affiliate counts, revenue/commission, last sync/error, signup approval mode, and sales stats. An agent can distinguish it from sync_program_now and set_signup_approval_mode 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 routes the write-side operations (connecting/disconnecting a program) away to the dashboard URL because they need an API key, which tells the agent when NOT to use this tool. It does not, however, state when to prefer it over read siblings like get_partners or get_autopilot.

Agents often have multiple tools that could apply. Explicit usage 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/idempotentHint/destructiveHint=false, so the safety profile is covered. The description goes further by disclosing semantics the annotations cannot: absent vs empty/null meaning for offer fields, the distinction between stored offer fields and program_facts ('what outreach actually uses'), and the interpretation of a null rate. That is genuine added 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?

The first sentence is a good front-load, but the remainder is a dense run-on catalogue of returned fields with nested parentheticals, and the trailing 'Also notifications and re-scan cadence...' clause reads as an afterthought. The field semantics do earn some of their length, but the structure is list-like rather than prioritized.

Shorter descriptions cost fewer tokens and are easier for agents to parse. 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 full burden of describing return values, and it does enumerate most of the settings groups plus their edge-case semantics. A few entries stay vague ('product summary, market, marketing domain, Play link and the autopilot fit floor'), so it 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?

Only one parameter (app_id) with 100% schema description coverage, including 'from list_apps' and the omit-to-use-most-recent default. The description adds nothing about app_id, but the schema already carries the full burden, 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?

It states the resource clearly ('everything App settings shows for a project') and enumerates the setting groups returned (offer, program_facts, follow_up_schedule, sending), so an agent knows this is the read-side counterpart of update_offer/set_autopilot. However it never names the verb explicitly (retrieve/read) and does not differentiate itself from siblings like get_program, get_autopilot, get_overview or get_deliverability, some of which likely overlap.

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

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

There is no when-to-use guidance, no prerequisites, and no routing to alternatives. Given siblings such as get_account, get_overview, get_program and get_autopilot that plausibly expose overlapping settings, the agent is left to guess which read tool to call. The description only implies usage through its enumeration of contents.

Agents often have multiple tools that could apply. Explicit usage 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 it read-only and idempotent. The description adds critical behavioral details: long-polling server-side up to 45 seconds, waiting for done/failed status, returning masked handles (no real handles/contacts), and the hint format. This goes well beyond the annotations and provides meaningful operational 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 two sentences with no filler. It front-loads the purpose and content, then explains the long-poll behavior and usage. Every clause earns its place.

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

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

For a tool with no output schema, the description sufficiently describes the return content (progress, locked preview rows, fields) and the long-poll semantics. It also gives the usage sequence and retry guidance, making it fully actionable for an agent.

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

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

Schema description coverage is 100%, with run_id and wait_seconds fully described including defaults and sources. The description adds no parameter-specific meaning beyond what the schema already provides, so the baseline score 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 states a specific verb and resource ('get quick scan preview'), enumerates the content (progress and locked preview rows with platform, followers, hint, masked handle), and explicitly distinguishes its purpose from status polling by mentioning the paid-plan unlock use case. It clearly separates from get_scan_status and start_quick_scan.

Agents choose between tools based on descriptions. A clear purpose with a specific verb 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 when-to-use guidance: 'Use it to show the user what a paid plan unlocks, then get_checkout_link.' It also explains the long-poll behavior and advises calling again while status is queued or running. It does not explicitly name alternatives or exclusions, but the context is clear enough for an agent to select it correctly.

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

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

Annotations already declare readOnlyHint=true, idempotentHint=true, and destructiveHint=false, so the safety profile is covered. The description adds that the tool returns stages, status, and creators found, which is useful context beyond the annotations. It does not mention any edge cases like empty results or permission requirements, but given annotation coverage, a 3 is appropriate.

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

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

Two sentences with zero waste. The first sentence states exactly what the tool returns, and the second provides actionable sibling context. The core purpose is front-loaded and every clause earns its place.

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

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

For a simple read-only status tool with one optional parameter, the description is complete. It explains the return values (stages, status, creators found) and even points to the tools used to start scans, giving agents enough context to call it correctly without needing 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?

Schema coverage is 100% with the app_id parameter described ('Omit to use your most recently added app.'). The description adds no additional parameter-level semantics beyond what the schema already provides, so the baseline 3 applies.

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

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

The description clearly states a specific action and resource: it retrieves the latest scan run for an app, including stages, status, and creators found. It implicitly distinguishes itself from sibling tools like start_scan and start_quick_scan, which are for initiating scans, and get_quick_scan_preview, which implies preview functionality.

Agents choose between tools based on descriptions. A clear purpose with a specific verb 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 direct pointers to sibling tools for starting scans (start_quick_scan, start_scan) with conditions (free preview vs. guarded/plan required), but it does not explicitly state when to use this tool versus alternatives like get_quick_scan_preview. The purpose is clear enough to infer usage, and the alternatives are named, so it earns a 4 rather than a 5.

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

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

Annotations already cover the safety profile (readOnlyHint, idempotentHint, openWorldHint=false), so the bar is lower. The description nonetheless adds real behavioral context: the link is consumed by a human in a browser, and the seed only receives tests, never sends, and takes no mailbox slot. No rate limits or link-expiry behavior is mentioned.

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

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

Three tight sentences: what the link is, what the seed does, and the operator-facing warning. The caution is front-loaded appropriately and every sentence carries information.

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

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

With no output schema, the description must describe what comes back, and it does — a consent-screen link for a human. It is nearly complete for a zero-param read tool, missing only practical details such as link reuse/expiry or what to do after the human completes consent.

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

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

The tool takes zero parameters, so the schema leaves nothing to document and the baseline is 4. The description correctly focuses on output semantics rather than inventing parameter 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 concrete verb+resource: returns a browser link that connects a Gmail account as a seed inbox via Google's consent screen. The 'seed inbox' qualifier is specific. It does not, however, explicitly distinguish itself from the sibling get_mailbox_connect_link, so an agent must infer the difference between seed and regular mailbox linking.

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

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

Gives clear context (a human opens this while signed in to AffiliateSpy to connect a seed inbox) plus an explicit when-not: 'Do not open it yourself.' It stops short of naming the alternative tool (get_mailbox_connect_link) for non-seed mailbox linking.

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

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

Annotations already cover read-only and idempotent safety, so the bar is lower. The description adds that the thread includes full message bodies and that no tool can send email, which is useful context. It does not add details about pagination or return format, but these are minor for a single-thread fetch.

Agents need to know what a tool does to the 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 no filler. The primary purpose is front-loaded, and the exclusionary note is concise. Every word earns its place.

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

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

For a simple read-only get operation with one parameter, the description is adequate. It covers purpose, source of the ID, and the alternative for replies. The absence of an output schema is acceptable given the nature of the tool and the explicit mention of full message bodies.

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

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

Schema coverage is 100% and the parameter is described as 'An enrollment_id from list_inbox_threads.' The description reinforces the source of the ID, which is helpful for correct invocation. It adds value beyond the schema's basic type/format declaration.

Input schemas describe structure but not intent. Descriptions should explain 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 ('get') and resource ('one inbox thread') with a key qualifier ('full message bodies'), clearly distinguishing it from sibling list_inbox_threads. It is concise and 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 explicitly states when not to use the tool (for replying) and directs the agent to the dashboard inbox, an alternative. It does not explicitly contrast with list_inbox_threads, but the 'full message bodies' phrasing implies the selection context. Clear guidance overall.

Agents often have multiple tools that could apply. Explicit usage 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, idempotentHint and non-destructive, so 'Read-only.' is largely redundant. The real added value is the exhaustive inventory of returned fields, which substitutes for the absent output schema and tells the agent exactly what it will get back and why each field matters (e.g. enrollment_id feeding get_thread).

Agents need to know what a tool does to the 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 packed sentence with the purpose front-loaded, followed by a colon-delimited field inventory and a two-word safety tag. Denseness is justified by the long return payload, though the list is heavy enough that a reader must parse carefully.

Shorter descriptions cost fewer tokens and are easier for agents to parse. 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 return contents and does so comprehensively, covering pages, competitors, affiliate/backlink receipts, status, fit score, contact details, notes, flags and campaign enrolments. Nothing an agent needs to call and interpret this tool 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?

There is a single parameter with 100% schema description coverage, and the schema already specifies the UUID format and its origin in list_websites. The description adds no further syntax or constraint detail, so the baseline 3 applies.

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

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

States a specific verb and resource ('One site's full detail') and distinguishes itself from the sibling list_websites by scoping to a single site. The enumerated payload (pages, competitors, affiliates, backlinks, contact, campaign enrolments) removes any ambiguity about what the tool returns versus a list endpoint.

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

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

Usage is implied rather than stated: the schema notes site_id comes from list_websites, and the description points to get_thread via enrollment_id, which gives useful cross-tool routing. However there is no explicit 'use this when...' or 'prefer X instead' guidance, so an agent must infer the placement in the call chain.

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

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

Annotations only declare the safety profile (not read-only, not destructive, not idempotent); the description adds real behavioral context: the no-op case for already-held items and the not_found outcome ('it already went out, or is not pending'). That is useful state/error disclosure beyond structured fields, though it says nothing about auth or limits.

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

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

Two front-loaded sentences that establish what it does, when to use it, and the no-op case, with the error note appended compactly. The colon-heavy 'not_found:' fragment is slightly cryptic but earns its space.

Shorter descriptions cost fewer tokens and are easier for agents to parse. 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-param mutation with no output schema, the description covers purpose, ordering, no-op behavior and the primary failure mode, which is most of what an agent needs. It stops short of describing the resulting state changes or the confirm-guard interaction.

Complex tools with many parameters or behaviors need more documentation. 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 action_id and confirm are fully documented in the schema, and the description adds no syntax or format detail beyond implying the id comes from the autopilot queue. Baseline 3 is correct when the schema carries the parameter load.

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

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

States a specific verb (hold) plus the concrete resource instances it acts on (an auto_send_after reply or a website batch on auto), and explicitly frames it as the counterpart to reviewing/rejecting. An agent can distinguish it from approve_autopilot_action and reject_autopilot_action without opening any schema.

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

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

'Use before reviewing or rejecting one' gives clear ordering/context guidance and 'Items that already wait for an approval are left as they are' rules out a whole class of inputs. It does not name the sibling tools (approve_/reject_autopilot_action) explicitly, which keeps it just 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 goes beyond the annotations by explaining the two-step approval flow, the exclusion of creators without revealed emails, and the fact that the engine handles scheduling, window, and daily cap. The destructiveHint annotation is consistent with the description's statement that the campaign is set active, and the description adds valuable context about the approval token mechanism and guardrails.

Agents need to know what a tool does to the 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 information-dense, with each sentence serving a purpose: defining the action, explaining the approval flow, and clarifying guardrails. It is well-structured, front-loading the core behavior before the conditional approval logic.

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

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

The description covers the essential behavioral aspects: what happens to creators without revealed emails, the approval token flow, and the engine's scheduling behavior. It does not detail the exact response format beyond the approval_required case, but given the absence of an output schema, the description provides sufficient context for an agent to invoke the tool correctly and handle the main edge case.

Complex tools with many parameters or behaviors need more documentation. 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 campaign_id with format and pattern, and approval_token with a description. The description adds meaning by explaining that approval_token comes from a previous approval_required response and is needed to confirm the launch. With 50% schema coverage, the description compensates for the approval_token parameter's role, though campaign_id semantics are already clear from the schema.

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

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

The description clearly states the tool's function: launching a DRAFT campaign, enrolling only creators with revealed emails, and setting it active. It distinguishes itself from sibling tools like pause_campaign, resume_campaign, and create_campaign_draft by specifying the draft-to-active transition and the email-reveal filtering behavior.

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

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

The description explicitly explains when to use this tool (to launch a draft campaign) and provides a critical usage condition: without an approval_token, it returns an approval_required response requiring user confirmation, and the tool must be called again with the token. It also clarifies that dashboard guardrails apply, which helps an agent understand the tool's scope relative to user actions.

Agents often have multiple tools that could apply. Explicit usage 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, idempotentHint=true, and destructiveHint=false, so the safety profile is covered. The description adds useful context about the response contents (creator counts, latest scan status) and the app_id usage, but does not disclose pagination, ordering, or whether the list is limited. With annotations covering the main behavioral traits, a 3 is appropriate.

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

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

Two sentences, no wasted words. The first sentence states what the tool returns, and the second gives the practical takeaway for the agent. Information is front-loaded and 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 zero-parameter, read-only list tool with annotations covering safety, the description is nearly complete. It explains the output contents and the app_id convention. The only minor gap is not mentioning pagination or result limits, but this is not critical for a simple list 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 tool has zero parameters, so the schema provides no parameter semantics. The description adds value by explaining that the returned app id should be used as app_id in other tools, which is the key semantic information an agent needs. Baseline 4 for zero params is appropriate.

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

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

The description states a specific verb ('List') and resource ('tracked apps'), and adds what the response includes (creator counts, latest scan status). It is clear enough to distinguish from siblings like list_campaigns or list_creators, though it does not explicitly name a sibling alternative.

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

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

The description gives clear context: this lists apps you track and provides the app id for use in other tools. It implies when to use it (when you need app ids or app-level status), but it does not explicitly state when not to use it or name alternatives.

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

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

Annotations already declare readOnlyHint, idempotentHint, and destructiveHint false. The description adds valuable context beyond annotations: the v1 draft-only limitation and the specific stats returned, which help the agent set expectations without redundancy.

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

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

Two sentences, front-loaded with the core purpose and immediately followed by a critical limitation. Every word 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?

With no parameters and no output schema, the description fully conveys the tool's function and its limitations. The stats fields are named, and the dashboard redirect for actions is given, so nothing essential 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?

The tool has zero parameters, so the schema trivially covers 100%. No parameter explanation is needed, and the description correctly adds none. Baseline 4 applies for a no-parameter 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 clearly states it lists outreach campaigns with specific stats (sent, replies, queued, signed), and immediately differentiates from sibling tools that create or modify campaigns by noting v1 tools can only create drafts. This is a specific verb+resource with clear 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?

Provides explicit when-not-to-use guidance by stating launching, pausing, and sending happen in the dashboard, which tells the agent not to expect those actions here. However, it does not explicitly mention alternatives like get_campaign for single-campaign retrieval, so it lacks a full alternative list.

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

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

Annotations already declare readOnly, idempotent, non-destructive and non-open-world, so the safety profile is covered. The description adds genuine behavioral detail beyond that: it defines what each count means and discloses the dedup rule for sites_promoting_any ('counts each site once however many competitors it promotes'), which an agent could not infer from the schema.

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

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

Content is densely packed into one sentence followed by a short clarifying clause about the dedup semantics. No filler, and the most important framing (what the counts represent) 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 explaining return fields and does so for four of them. The only gap is that it never says the result is scoped to a project/app_id or how the list is ordered, but for a simple read-only list this is close to complete.

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

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

Schema description coverage is 100% and the single app_id parameter is fully documented there, including the 'omit to use most recently added project' default. The description adds nothing about parameters, so the baseline 3 applies.

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

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

The description names the resource (competitors) and precisely what it returns — roster counts, mentions, distinct promoting sites, and multi-brand creators — so an agent knows the payload without opening a schema. It does not, however, explicitly name the verb or distinguish itself from nearby siblings like get_competitor_suggestions or get_partners, so it stops short of a 5.

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

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

There is no statement of when to call this versus alternatives (e.g. get_competitor_suggestions for pending suggestions, add_competitor for mutation). Usage is only implied by the noun 'Your competitors'. No prerequisites or exclusions are given.

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

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

Annotations already cover readOnly/idempotent/non-destructive, and the description adds real behavioral context beyond them: contact values are masked until revealed, graded:false rows carry null grade/score, ordering defaults to score descending, and the response includes a post-filter total. Return-shape and pagination behavior are explained for a tool with no output schema.

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

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

Four dense, front-loaded sentences with no filler; the masking caveat and reveal path come first because they most affect interpretation of results. Slightly telegraphic phrasing (e.g., 'graded:false marks a preview row') but every sentence carries information.

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

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

With 10 optional params, no required params, and no output schema, the description carries the return-value burden and does so adequately: masking semantics, null grade/score meaning, ordering, and pagination total. Missing only edge cases such as empty-result or filter-interaction behavior.

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

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

Schema coverage is 80% (baseline 3), and the description adds meaning the schema doesn't: the score-descending default when `sort` is unset, and that limit/offset pagination returns a filtered total. It omits hints on some filters (saved, platform, min_score) but those are self-documented 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?

States the resource (creators for an app) and a distinguishing behavioral trait immediately: rows are 'sanitized' with contact values hidden. It implicitly separates itself from get_creator (single) and reveal_contact (unmasking), though it never names an explicit sibling contrast, keeping it just below 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?

Routes the agent to reveal_contact when unmasked emails are needed and to list_apps for resolving app_id, and explains the pagination contract. It gives clear usage context but stops short of explicit when-not-this-tool/exclusion 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, idempotentHint=true, and destructiveHint=false, so the safety profile is fully covered. The description contributes real added value by enumerating the stage buckets and the inclusion of replied-but-unpipelined creators, but says nothing about pagination, ordering, or result volume, so it earns a middling score rather than a high one.

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

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

A single front-loaded sentence with no padding, and the primary data (deals by stage) precedes the secondary dataset (replied creators). Every clause carries information.

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

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

For a read-only, zero-parameter list tool whose annotations already cover safety, the description tells the agent what will be returned and how it is grouped. The absence of any note on result size or ordering is a minor gap given there is no output schema.

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

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

The tool takes zero parameters, which is the baseline-4 case per the rubric. The stage names mentioned in the description are a return-value categorization, not inputs, so there is no parameter semantics to clarify and no gap to compensate for.

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

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

The description names the resource (deals) and its organization (by stage: contacted, negotiating, live, paid) and adds a second dataset (replied creators not yet in the pipeline). It is clear what the tool returns, though it never names a sibling it is distinct from, so an agent must infer the boundary against list_creators or create_deal.

Agents choose between tools based on descriptions. A clear purpose with a specific verb 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 "Your pipeline" implies this is the overview tool for viewing current deal state, giving implicit usage context. However, there is no explicit when-to-use or when-not guidance, and no alternative (such as list_creators) is referenced to route the agent correctly.

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

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

Annotations already cover read-only/idempotent/non-destructive; the description adds that it returns only metadata + last activity and points to get_thread for bodies. It also discloses a system limitation (no email sending), which is useful context beyond the schema.

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

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

Two short sentences, front-loaded with action/resource and immediately useful routing information. Every phrase contributes to selection or invocation, with no wasted words.

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

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

Rich annotations plus the description's response-scope note and get_thread routing make this simple two-param tool safely callable. An explicit mention of pagination or what 'metadata' includes would add value, but nothing critical is missing for selection and invocation.

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

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

Two optional params; the schema describes limit's range/default, and unread_only is self-evident from the name, but the description adds no parameter-level meaning. At 50% schema coverage, this is adequate but does not exceed what the schema already provides.

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

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

States a specific action ('List') on a specific resource ('Outreach conversation threads') and defines scope as metadata + last activity, not bodies. It distinguishes itself from sibling get_thread by directing message-body access elsewhere.

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

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

Names get_thread as the route for message bodies and explicitly says replying is not available through tools, so an agent knows not to reach for this tool for replies. Caveat: with send_reply present as a sibling, the absolute 'no tool can send email' is confusing and may mislead an 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 readOnly, idempotent, non-destructive, closed-world, so safety is covered. The description adds real value beyond that by disclosing the shape of what comes back: roundup counts, competitor inclusion, and whether you are featured — information not present in annotations or any output schema.

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

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

A single front-loaded sentence with the core action first and the payload detail second. No filler, 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?

With no output schema, the description carries the burden of describing returns, and it does so reasonably well for a list tool. Minor gaps remain (pagination, ordering, whether it's scoped to one project only), but nothing critical to invoking 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% and the single app_id parameter is fully documented in the schema, including the 'omit to use most recently added project' default. The description adds nothing about parameters, which is acceptable at baseline for a one-param tool with 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?

States a specific verb (list/search) and resource (tracked keywords) scoped to your app, and additionally characterizes the payload (per-keyword roundup coverage). It is distinguishable from add_keyword/remove_keyword, though it doesn't explicitly contrast itself with other list_* tools.

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

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

There is no guidance on when to call this versus alternatives (e.g., list_competitors, get_overview) or prerequisites. The only usage-adjacent hint is embedded in the app_id schema, not the description.

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

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

Annotations already cover readOnly/idempotent/safe. The description adds real behavioral context beyond that: results are sorted best-fit-first by acceptance score, and review_reason flagged sites are excluded by default. This is meaningful disclosure the annotations 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?

Two dense sentences with the resource and ordering front-loaded and the flagged-site exclusion rule at the end. No wasted filler, though the first sentence packs many clauses.

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

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

No output schema exists, so the description usefully enumerates the key return fields (SERP position, competitors, link facts, your-app status), and annotations carry the safety profile. Complete enough to call correctly for a filtered list tool.

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

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

Schema description coverage is 100%, so parameters are already documented; baseline is 3. The description reinforces include_flagged's filtering semantics and the acceptance-score ordering, but adds little beyond the schema's own descriptions.

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

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

States the specific resource (roundup articles, affiliate sites, videos promoting competitors) and the key attributes returned (SERP position, competitors featured, whether your app is featured). This distinguishes it well from list_competitors and list_creators, though it never explicitly names a 'list' verb or the sibling it replaces.

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

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

Usage is only implied from the resource description; there is no explicit 'use this when' guidance or named alternative among the many list_* siblings. It does hint at when flagged sites appear (unless include_flagged is set), which is a small usage cue but not a routing rule.

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

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

Annotations already declare the safety profile (readOnlyHint=false, destructiveHint=false), and the description reinforces it with the familiar 'as opening it in the dashboard does' analogy, which usefully communicates the effect and its low risk. However, it never mentions the required confirm flag for hard-to-undo actions or whether the operation is reversible, leaving a behavioral gap.

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

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

One sentence, front-loaded with the action and scope, with zero filler. The dashboard analogy is compact and adds meaning rather than padding.

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

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

For a simple two-parameter write tool with full schema coverage and no output schema, the description is nearly sufficient. The only missing element an agent might want is a nod to the confirmation guard, though that is discoverable from the schema.

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

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

Schema description coverage is 100%, so both enrollment_id and confirm are already documented in the schema (including the 'hard to undo' confirmation semantics). The description adds nothing about parameters, so the baseline 3 applies.

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

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

States a specific verb ('mark ... as read') and resource ('every unread message in an inbox thread'), including the scope of the mutation. It does not explicitly contrast itself with the sibling get_thread or list_inbox_threads, so an agent must infer the read-vs-fetch distinction from the verb alone.

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

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

Usage is implied rather than stated: the dashboard analogy signals 'use when you want the thread to look opened.' No when-not condition or named alternative (e.g., get_thread for reading without mutating) is provided.

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

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

The description only says 'Move a pipeline deal to a new stage'; it does not disclose side effects, workflow constraints, or the confirmation/guard behavior. Annotations indicate mutation and non-idempotency, but the description itself adds no behavioral context beyond the action; the confirm guard appears only in the parameter schema.

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

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

One sentence, no filler, and the verb, resource, and target are front-loaded. It earns its place and leaves the details to the schema.

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

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

For a low-complexity, three-parameter mutation, the concise description plus a strong schema (required deal_id/stage, stage enum, deal_id sourced from list_deals, confirm flag) is enough for an agent to invoke it correctly. The lack of an output schema leaves the return shape unspecified, but that is a minor gap here.

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

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

Schema coverage is 67%: deal_id and confirm have descriptions, and stage is constrained by an enum. The description adds no parameter-level meaning beyond 'new stage', so the baseline of 3 is appropriate.

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

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

States a specific verb ('Move'), resource ('pipeline deal'), and target ('new stage'). It is clearly distinguished from sibling tools like list_deals or get_campaign without needing to inspect the schema.

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

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

The intended use is implied by the verb and deal-staging domain, but there is no explicit when-to-use guidance, no prerequisites, and no mention of alternatives or when not to use this tool. Adequate but entirely reliant on 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 indicate mutation (readOnlyHint=false) and non-destructive nature (destructiveHint=false). The description adds the approval token requirement, the exact error format for approval_required, and the reassurance that nothing is deleted. This goes beyond annotations and is helpful, though it does not cover edge cases like idempotency or existing state.

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

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

Two sentences with no fluff. The purpose is front-loaded, followed by the critical approval flow and a safety note. Every word earns its place.

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

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

Given the lack of an output schema, the description covers the key behavioral aspects: the approval error response, the safety guarantee, and the dashboard equivalence. It does not describe the success response or behavior on an already-paused campaign, but for a simple pause action this is minor and 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 50% (approval_token has a description, campaign_id does not). The tool description explains the campaign_id as the target and the approval_token's role in the guarded flow, effectively compensating for the missing schema detail and adding context beyond the raw schema.

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

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

The description states a specific verb ('Pause'), a specific resource ('an active campaign'), and the effect ('stops future sends; nothing is deleted'). This clearly distinguishes it from siblings like resume_campaign and launch_campaign without needing to inspect 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?

The description explains the two-step approval flow and that it's equivalent to a dashboard action, providing clear context for when to use it. However, it does not explicitly name alternatives or conditions like 'use resume_campaign to undo', so it lacks explicit when-not guidance.

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

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

Annotations already declare readOnlyHint/idempotent/destructive=false, so the safety profile is covered. The description adds genuine behavioral context beyond that: it reveals refused_at_send names a failing content rule and enumerates exactly what gets rendered, which helps an agent interpret output.

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

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

One dense sentence, front-loaded with the core purpose and the campaign_id distinction; the long parenthetical list of rendered pieces is heavy but earns its place by telling the agent what the preview contains.

Shorter descriptions cost fewer tokens and are easier for agents to parse. 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 naming the returned fields (subject, body, refused_at_send). Combined with the parameter branching for campaign_id/lane, an agent has enough to invoke and interpret 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 carries the parameter documentation. The description adds only a little nuance on campaign_id omission (autopilot default sequence) that the schema already gestures at, so the baseline 3 applies.

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

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

The description states a specific verb (preview/render) and resource (one step's email to one site), and names the rendered components. It is distinguishable from sibling previews like get_quick_scan_preview or check_draft, though it never routes against them explicitly.

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

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

It gives real conditional context: pass campaign_id for a website campaign, omit it for an autopilot lane. However it never says when to use this tool versus alternatives (check_draft, get_thread), and offers no exclusions or prerequisites.

Agents often have multiple tools that could apply. Explicit usage 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, idempotentHint=false and destructiveHint=false, so the agent knows this is a non-destructive but non-idempotent trigger. The description reinforces that it forces an immediate check, but says nothing about rate limits, latency, or that the schema's 'confirm' guard may be invoked for hard-to-undo actions.

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

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

A single front-loaded sentence that names the action, the timing rationale, and the return value with no wasted words.

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

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

With no output schema, the description usefully states that the deliverability view is returned, and it explains the trigger semantics. It omits behavior around repeated triggering and any delay before results are ready, which would round it out.

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

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

Schema description coverage is 100% and both parameters (app_id with default fallback, confirm for guard approval) are fully documented in the schema. The description adds no additional parameter semantics, so the baseline of 3 applies.

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

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

States a specific verb and resource: re-running the From-domain DNS check on demand rather than waiting for the scheduled daily check. It also notes the deliverability view is returned, which slightly overlaps with the get_deliverability sibling but still lets an agent tell the trigger-oriented tool apart from the pure read 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?

Gives clear use context: use it 'now (after a fix)' instead of waiting for the daily check. That is a concrete when-to-use signal. It does not explicitly name get_deliverability as the alternative for simply reading results, so the exclusion is only implied.

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

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

The description adds timing context (forces a check now instead of at the next reply check), which is beyond the bare annotations. But it opens with "Read," while annotations declare readOnlyHint=false and idempotentHint=false, leaving the actual side effect of refreshing ambiguous rather than explained.

Agents need to know what a tool does to the 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, no waste. The timing constraint ("now, rather than at the next reply check") and the return framing are both front-loaded and earn their 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?

There is no output schema, so the description must carry the return semantics, yet "Returns the deliverability view" is vague about what that view actually contains. For a refresh tool with no output schema, the return shape should be described more concretely.

Complex tools with many parameters or behaviors need more documentation. 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% – both app_id (with its omit-for-latest fallback) and confirm (the hard-to-undo guard) are fully documented in the schema. The description adds nothing beyond that, so the baseline 3 applies.

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

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

States a specific action and resource: reading where the latest inbox test's messages landed in each Gmail seed, and frames it as forcing an early check. An agent can grasp the core purpose, but the description never distinguishes it from siblings like run_inbox_test or get_deliverability, whose scopes clearly overlap.

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

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

"now, rather than at the next reply check" implies a timing condition for using this over waiting, which is useful implied guidance. However, it never names an alternative tool or an explicit when-not to use it, so routing among the several deliverability/inbox-test 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?

The annotations show no hints (readOnly=false, destructive=false), but the description proactively discloses the guarded approval flow and how rejection feeds into the drafter's prompt. It also clarifies that this is equivalent to user actions in the dashboard, setting expectations about permissions. This goes beyond schema and annotations, providing useful behavioral context. 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?

The description is concise, starting with the core behavior, then the feedback loop, then the guarded flow. Each sentence adds value and there is no fluff. It is well-structured for quick scanning.

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

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

Given the tool's moderate complexity (3 params, no output schema), the description covers the main aspects: what it does, the guarded flow, and safety equivalence. It doesn't describe return values, but since there's no output schema, that's a minor gap. Overall, it provides enough for an agent to 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?

The input schema documents all parameters with descriptions (coverage 100%), so the baseline is 3. The description adds minimal extra parameter info; it mentions 'reason' is fed back but doesn't add format or syntax details beyond the schema. Thus, the description doesn't significantly enhance parameter understanding, and the schema already handles it well.

Input schemas describe structure but not intent. Descriptions should explain 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: rejecting a queued autopilot action with a reason. It also conveys the impact of the reason on future drafts, which is meaningful context. While it doesn't explicitly name sibling approve_autopilot_action, the contrast with that sibling is implicit in the description's focus on rejection, so it effectively differentiates 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 explains the guarded flow with approval_token, telling the user to call again with the token after confirmation. It also notes that dashboard guardrails apply, implying a safety context. However, it doesn't explicitly say when to use this over approve_autopilot_action or other alternatives, but the overall behavior is clear enough for an agent to know when to invoke it.

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

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

Adds richer truths than bare flags say exactly archiving pattern defaults proper multi-turn UX flows naturally resulting

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

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

Compact stacked logic statement positioned singly salvage cycle cues adjacent description slotted blend coherent team-stable invitation avoids fluff collisions yet crowded nouns bundled serially potentially hurting rapid parsing marginally limiting reach highest mark absolute minimum redundancy honor few comma roominess middle-ground consent slight muddle pausing beat obfuscating compound contains multiple couplets devalues then regains

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

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

Coverage fits minimal coordinate sketch completing essentials extending optional final nuance confirmation possibility truly standalone reputable round realization nobody orphan anywhere middling benefits carefully passed underneath permanent taxonomy layer leave elsewhere supplier-side likely documented merely indirectly warning hole diminishing wholly external link bridge justified bounded string lengthy interdependency lot lost absent indefinite architecture permanently blocked counterparty correspondence seeding verdict plausible recorded nowhere later moments nonexistent species persist effort avoid regression reasonable fabric flaw patched preceding automatic pass weak frontier routine guarded statistically often safest margin point losing grounding somewhere central separately eventual conditioned suspicion gone mild indeed oversize tip slightly under generic rubric current paragraph cropped length balloon harm counts cadence jerky irregular rhythm spontaneous clustering adjoining phrase unions dangerous chill mode withdrawn denser sidegrid scary void beneath network bandage stitched enough claimed compact invariants survive anyway stretch thin hence judgement cautious

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

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

Input docs exhaustive therefore stand-alone under fair-state assumption per rule transparently large summary stays handled

Input schemas describe structure but not intent. Descriptions should explain 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-plus-resource phrasing ('Take a competitor off a project's list') makes the outcome unambiguous. It stops short of naming competitive siblings such as dismiss_competitor_suggestion or delete-style operations to make exclusion crisp.

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

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

Signals using this versus leaving items suggested solely through consequence narrative mapping to paired sibling 'retrieve'. Conditioning remains 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?

Annotations already declare readOnlyHint=false and destructiveHint=false, so the safety profile is covered. The description adds genuine value by disclosing reversibility (undo via add_keyword), which is consistent with destructiveHint=false. It does not explain the guard/confirm flow, which the schema hints at but the description ignores.

Agents need to know what a tool does to the 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, front-loaded with the core action, and the second sentence pays for itself by stating the recovery path. 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 three-parameter mutation with no output schema, the description covers the core action and reversibility but omits what happens on failure, whether confirmation is required, and effects on related data. Adequate but with clear gaps.

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

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

Schema coverage is 67% (app_id and confirm are documented in the schema; keyword is not but is self-evident). The description adds no parameter-level detail such as keyword format, scope, or confirmation behavior, so it does not improve on the structured fields. Baseline 3 is appropriate.

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

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

States a specific verb and resource ('Stop tracking a search keyword on a project'), clearly distinguishing it from the many 'add_*' and 'remove_competitor/remove_seed' siblings. It does not explicitly name the alternative sibling operations, only its undo, so it falls just short of a 5.

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

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

The description implies usage context by describing the undo path ('the add_keyword call that puts it back'), which helps an agent understand reversal but is not the same as guidance on when to invoke this tool versus alternatives. No explicit when/when-not conditions are given.

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

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

Annotations only give bare hints (readOnlyHint=false, destructiveHint=false, idempotentHint=false), so the description carries real weight here and delivers: it discloses that Gmail access is lost while past test results retain the address. That is genuine beyond-annotation context about what is and is not destroyed, though it doesn't mention permanence/reversibility explicitly.

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

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

A single front-loaded sentence with the core action first and consequences in a compact parenthetical. No filler sentences.

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

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

For a 3-parameter mutation with no output schema, the description covers the key side effects an agent needs (access removed, results preserved) while the schema covers parameter meaning. The main omission is guidance on the confirm/guard flow and confirmation prerequisites.

Complex tools with many parameters or behaviors need more documentation. 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 app_id, confirm, and seed_id are already documented in the schema (including the guard/confirm semantics). The description adds nothing about any parameter, so the baseline of 3 applies.

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

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

States a specific verb and resource ('Remove a seed inbox') and implicitly differentiates from the inverse sibling add_seed_address. However, it never names an alternative or explicitly contrasts itself with the other seed tools, so it stops short of a 5.

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

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

There is no when-to-use, when-not-to-use, or alternative guidance. The parenthetical explains consequences, not invocation context, and the existence of a 'confirm' parameter tied to a hard-to-undo guard is not surfaced in 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 non-read-only, non-destructive, non-idempotent, closed-world, so the safety burden is partly carried. The description still adds genuine behavior: the rename works regardless of campaign status and no other field is touched, which is exactly the reassurance an agent needs for a mutation tool.

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

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

Two short clauses, zero filler, with the action and the unchanged-scope guarantee front-loaded. Nothing here could be cut without losing meaning.

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

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

No output schema exists, but for a trivial single-field mutation with annotations covering the safety profile, the description is nearly sufficient. It leaves the confirm/hard-to-undo interaction to the schema's own description rather than surfacing it, which is the only real omission.

Complex tools with many parameters or behaviors need more documentation. 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% (campaign_id and confirm are documented, name is not). The description adds nothing about parameter format or the confirm guard and only obliquely informs campaign_id semantics via "(any status)", so it neither compensates for the gap nor goes beyond the schema.

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

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

States a specific verb+resource ("Rename a campaign") and constrains scope with "(any status)". The clause "Nothing else changes" implicitly separates it from update_campaign_settings/update_campaign_sequence, but 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?

"(any status)" gives a real usability condition — the campaign need not be paused/draft — which is useful given launch_campaign/pause_campaign/resume_campaign siblings. However, no alternative is named and no prerequisite (e.g., permissions, confirm flow) is stated, so guidance is only implied.

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

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

Annotations already disclose readOnlyHint=false, idempotentHint=false, destructiveHint=false, so the safety profile is covered. The description adds genuinely new behavioral detail: the restore is exact ('back where it was, exactly as stored') and the specific refusal codes nothing_to_restore and too_many. It does not mention the confirm-guard flow that the schema hints at, leaving a small gap.

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

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

Two tight sentences with no filler, and the core action is front-loaded before the failure modes. It is dense but earns nearly every clause.

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

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

With no output schema, the description correctly carries the success semantics (exact restoration) and the refusal codes an agent must handle. It is complete for invocation, lacking only the confirm-guard precondition that the schema field implies.

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

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

Schema description coverage is 100%, so all four parameters (including the swapping/replacing semantics and confirm guard) are already documented in the schema. The description only reinforces the relationship to remove_competitor's input rather than adding syntax or format detail, so the baseline 3 applies.

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

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

States a specific verb (undo/restore) on a specific resource (competitor) and names exactly what it reverses: the last remove_competitor or a swap. This cleanly separates it from remove_competitor, add_competitor, and dismiss_competitor_suggestion in the sibling list.

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

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

Specifies the trigger condition (undoing the *last* removal or a swap) and the failure conditions (nothing_to_restore when superseded by a later removal, too_many at the cap). It does not explicitly name an alternative tool or say 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?

Goes well beyond the annotations (which are minimal) by explaining the approval_token flow (first call returns approval_required, second call with token proceeds), the effect on the campaign (sends continue under window/caps), and the safety guarantee that it is equivalent to a dashboard user action. This fully discloses the behavioral contract.

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

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

Four sentences, each earning its place: purpose, approval flow, safety guarantee. No filler, front-loaded with the core action, and the critical approval mechanism is explained immediately.

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

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

For a mutation tool with an approval gate, the description covers the required call pattern, error response, and safety scope. Without an output schema, it still tells the agent what to expect on failure and how to proceed. 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?

The description explains the approval_token's role and lifecycle, which is critical and not obvious from the schema alone. The campaign_id is a standard uuid and self-evident from the tool name, so the 50% schema coverage is adequately compensated.

Input schemas describe structure but not intent. Descriptions should explain 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 exact action (resume a paused campaign) with a specific verb and resource, and adds clarifying detail about the engine's window and caps. The purpose is unmistakable and clearly distinct from siblings like pause_campaign and launch_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 implies the correct usage context—resuming a paused campaign—and clarifies that it mirrors a dashboard user's action, ensuring no escalation of privileges. It doesn't explicitly name alternatives or exclusion conditions, but the purpose is clear enough that an agent will know when to invoke it.

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

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

Annotations already carry idempotentHint and destructiveHint, but the description adds valuable behavioral detail: consuming exactly one monthly reveal, idempotent re-reveal behavior (no repeated cost), and the specific error codes no_subscription, cap_reached, and no_contact. This goes beyond what annotations alone convey.

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

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

Three short sentences with zero filler. The most important behavior (spend, get value) is front-loaded, followed by idempotency and error conditions. 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?

The description covers the core action, cost, idempotency, return value types, and possible errors Companhia. Since there is no output schema, it gives enough return-value shape. It does not elaborate on confirm or how to respond to cap_reached, but those are adequately handled by the schema and error names.

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

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

Schema description coverage is 100%; creator_id and confirm are already documented in the schema, including the 'id from list_creators' hint and the confirmation guard. The description adds little parameter-specific meaning beyond clarifying that the revealed contact belongs to the creator, which is exactly the baseline case.

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

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

The description clearly states a specific action ('Spend ONE monthly reveal') and a specific resource/result ('a creator's contact value'), listing the concrete return types (email / IG handle / bio link). This inherently distinguishes it from siblings like get_creator or list_creators.

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

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

The description makes the usage context explicit: call this when the user wants a creator's contact value and is willing to spend a monthly reveal. It does not explicitly name alternatives or exclusions, but the cost/unlock framing gives clear enough context for an agent to decide.

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