AfterLaunch

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

Adds substantive behavior beyond the annotations: idempotency ('a repeat never starts another worker'), a conditional side effect, cost ('Free'), and an auth scope. With destructiveHint=true already declared, this is meaningful extra context, though reversibility (undo_move) and failure behavior are unstated.

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

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

Four short sentences, each earning its place, with the consent gate front-loaded before the mechanical details. 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 7-parameter, open-world, destructive tool with no output schema, the description covers the core accept flow and idempotency but omits the retry/expected_* path and any outcome description. Annotations cover the safety profile, but the description leaves notable 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 71%, so the schema carries most parameter meaning (target enum effects, operation/retry requirements). The description adds no parameter-level detail and instead references 'launch_won', which is not a parameter, leaving expected_legacy_updated_at and retry mechanics entirely to the schema.

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

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

States a specific verb+resource ('accept a move') and describes the effect: recording a durable preparation attempt and conditionally starting the worker. This distinguishes it from sibling mutators like ship_move/skip_move/undo_move, though it never names them. Clear but without explicit sibling differentiation.

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

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

Gives a real precondition ('only after the founder says yes') and a gating condition for the side effect (launch_won true), plus the 'act' scope requirement. It stops short of naming alternatives such as review_move or ship_move when the founder has not said yes.

Agents often have multiple tools that could apply. Explicit usage 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: states the 10-rival cap, the idempotent dedup rule, that the call is free, that it requires the 'act' scope, and what the response contains. The destructiveHint=true annotation is not contradicted by the text, which describes an additive write with existing entries preserved.

Agents need to know what a tool does to the 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, then explicitly partitioned into WHEN and WHAT COMES BACK sections. Every clause carries information (precondition, limit, dedup, cost, scope, return) 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?

Despite having no output schema, the description compensates by describing the return value ("the roster, the new rival marked"). Combined with the limits, auth scope, and dedup behavior, an agent has everything needed to call this correctly.

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

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

Schema description coverage is 100%, so both 'domain' and the optional 'name' are already documented, including the default-to-domain behavior. The description adds only the dedup matching semantics ("by domain or by name"), 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 (add), a specific resource (one company/rival), and its downstream effect (measured by the next AI visibility scan and carried by every competitor read). It is clearly distinguishable from the read-side sibling get_competitors, which only lists the roster.

Agents choose between tools based on descriptions. A clear purpose with a specific verb 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 an explicit gating precondition ("only after they say yes to that rival") and handles the duplicate case ("a rival already on the roster, by domain or by name, is left as it is"). It does not name a sibling alternative such as get_competitors for the read case, so it falls short of a full when/when-not/alternative treatment.

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

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

Annotations declare destructiveHint=true, and the description adds real context beyond them: no publishing occurs, it is free, and it requires the 'act' scope. It does not explain what happens when the expected states/updated_at mismatch (presumably a concurrency failure), which is the key risk for a destructive write.

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

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

Three tight sentences, front-loaded with the intent and followed by the inputs and safety/side-effect caveats. Every sentence carries information; no 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 9-parameter destructive mutation with no output schema, the description covers intent and scope but omits the 'note' parameter and the failure mode when expected_move_state/expected_*_updated_at don't match current state.

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

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

Schema coverage is only 11%, so the description must compensate, and it does name prepared_content/asset_url, move and legacy job states, and updated_at. But it gives no format guidance for the timestamp/state fields, and the 'note' parameter is never mentioned.

Input schemas describe structure but not intent. Descriptions should explain 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 object: apply the user's explicit decision to adopt work prepared before attempt tracking (a null attempt) as an accepted move's prepared result. The 'legacy/null attempt' framing distinguishes it from sibling accept_move, though the contrast 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 the trigger condition (user's explicit decision after inspecting prepared content or asset URL) and a clear exclusion ('This never publishes anything'), which steers agents away from ship_move. It does not explicitly contrast with accept_move, leaving some ambiguity.

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

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

Adds substantial context beyond the annotations: no verdict is recorded, the operation is free, it requires the 'act' scope, and it is idempotent on an already-archived move. The annotations only declare destructiveHint=false/readOnly, so the description carries the real behavioral detail.

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

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

Two sentences, front-loaded with the purpose and sibling comparison, followed by the operational facts (cost, scope, idempotency). No filler.

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

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

For a single-parameter mutation tool with no output schema, the description covers everything an agent needs: what it does, how it differs from the closest sibling, cost, authorization scope, and idempotency behavior.

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

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

Schema description coverage is 100% and the single move_id parameter is fully documented in the schema ('Move id (uuid), from list_feed'). The description adds no parameter-level detail beyond that, so the baseline of 3 applies.

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

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

States a specific verb and resource ('archive a growth move') and immediately positions it against the sibling skip_move ('a lighter dismissal than skip'). An agent can distinguish it from skip_move and dismiss_gap without reading 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?

Gives clear selection context by contrasting with skip ('lighter dismissal than skip, with no verdict recorded') and states the cost and required 'act' scope. It doesn't explicitly say when-not to use it or name other alternatives, but the comparative framing is actionable.

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

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

Goes well beyond the destructive=true annotation by specifying exactly what happens (shipped move archived, completion history kept, no follow-through restart), the cost ('Free'), and the required auth ('act' scope). This is rich behavioral context an agent needs before a destructive mutation.

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

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

Three dense sentences that are front-loaded with the core action and its consequences, then the parameter guidance, then cost/scope. Every clause carries meaning, though the middle sentence is packed.

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

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

For a destructive tool with 8 params (3 required), legacy branching, and no output schema, it covers effects, prerequisites, and the legacy-vs-current distinction well. It omits mismatch/error behavior and the response shape, leaving 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 description coverage is only 25%, so the description must compensate. It explains the current vs legacy branching ('Pass the exact current job and attempt; legacy work also needs the exact move and legacy job states and updated_at'), clarifying the otherwise-cryptic expected_* concurrency parameters; only the note and move_id meaning are left implicit.

Input schemas describe structure but not intent. Descriptions should explain 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 ('correct a growth move's recorded publication') and the concrete effect (shipped move archived, completion history kept, no paid follow-through restarts), which distinguishes it from ship_move. It doesn't name sibling alternatives like undo_move or archive_move, so it is clear but not fully differentiated.

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

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

Gives a clear trigger condition: use when applying the user's explicit decision that the recorded publication is wrong, and clarifies it 'never publishes anything.' It stops short of naming when-not or alternative tools among the many siblings.

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

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

With annotations already declaring readOnlyHint=false, openWorldHint=true, destructiveHint=true, the description adds real context beyond them: 'act' scope required, permanently bound to your own enrollment, no charge to your own account, and Founder-only growth controls unlocking after external payment. There is a mild tension with destructiveHint=true given the emphatic 'charges nothing itself', though it is explained rather than contradicted.

Agents need to know what a tool does to the 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 key constraint ('Only mints a link') and each sentence carries distinct information (no charge, external payment flow, trial eligibility, scope, enrollment binding). Slightly dense but 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 parameterless tool with no output schema, the description covers what an agent needs: the returned checkout_url, that the user (not the agent) completes payment in a browser, the auth scope required, and the post-payment consequence. 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?

Zero parameters, so the schema baseline applies (4). The description confirms the tool is parameterless and fixed to the Founder plan / caller's enrollment, which is the only semantic detail an agent needs here.

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

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

States a specific verb and resource ('mints a link: returns a hosted checkout_url for the Founder plan') and immediately scopes it apart from the payment-taking siblings by declaring it 'takes no card or payment details and charges nothing itself'. An agent can distinguish this from create_topup without reading 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 use: Founder plan, reachable on a free trial, and the user must open the URL in their own browser to pay. It does not explicitly name create_topup as the alternative for actually taking money, so the when-not condition 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?

Adds real context beyond the annotations: no card/payment details are handled, payment occurs only on the hosted page, the user opens it in their own browser, and credits land only after payment. It also discloses auth/plan requirements. The only gap is that it never addresses why the operation is flagged destructiveHint=true, leaving that signal unexplained.

Agents need to know what a tool does to the 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 key constraint ('Only mints a link') and every sentence carries a distinct fact about payment, scope, or enrollment. It is dense but slightly run-on, packing four separate concerns into a single flowing block rather than clearly separated statements.

Shorter descriptions cost fewer tokens and are easier for agents to parse. 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 names the returned artifact (checkout_url) and explains prerequisites and side effects. It omits details an agent might need, such as link expiry, behavior when a pending link already exists, or how pack size maps to credit amounts.

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

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

Schema description coverage is 100% and there is a single enum parameter whose allowed values the schema already documents. The description repeats the pack sizes but adds no format, default, or behavior beyond what the schema provides, so the baseline 3 applies.

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

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

States a specific verb and resource ('Only mints a link: returns a hosted checkout_url for a credit top-up') and immediately scopes the tool by clarifying it takes no payment. This distinguishes it from the sibling create_checkout without the agent needing to open 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?

Gives concrete preconditions for use: requires the 'act' scope, the Founder plan (not a free trial), and is bound to your own enrollment. It does not, however, name an alternative sibling (e.g. create_checkout) or state when not to use this tool, so it stops short of explicit 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 declare destructiveHint=true and openWorldHint=true, yet the description still adds substantial context: the credential is deleted, Google tokens are separately revoked, the call is idempotent ('disconnecting something that was never connected changes nothing'), it is free, and it degrades measurement/distribution. This is exactly the extra behavioral detail annotations can't 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?

Four tight sentences, each carrying distinct information (action, revocation, idempotency, consequence + caution + cost), with the core action front-loaded and no filler.

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

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

For a single-parameter destructive mutation with no output schema and annotations already covering the safety profile, the description covers everything an agent needs: what is deleted, idempotent behavior, blast radius, cost, and the human-confirmation requirement.

Complex tools with many parameters or behaviors need more documentation. 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 provider parameter even lists its enum-like values (ga4, gsc, gbp, linkedin, reddit). The description only reframes provider as 'growth data source or distribution channel', adding no syntax or format detail beyond the schema, so baseline 3 applies.

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

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

The description gives a specific verb and resource ('disconnect a growth data source or distribution channel') and elaborates exactly what is destroyed (the stored credential, plus Google-side revocation). It is unambiguous against its read-only siblings, though it never names list_connections or start_connection explicitly to route the agent.

Agents choose between tools based on descriptions. A clear purpose with a specific verb 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 supplies real usage context: the operation narrows what the engine can measure and distribute, and instructs the agent to confirm with the founder first. There is no explicit when-not or named alternative, but the consequence framing plus the confirmation prerequisite is strong 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?

Adds substantial context beyond the annotations: idempotency ('a gap already shipped or archived is left as it is'), cross-surface effect (stops re-proposal here AND on the growth Feed), auth requirement ('act' scope), plan availability (free on every plan), and that the reason feeds ranking. The destructiveHint annotation is consistent with a state-changing dismissal, and the description clarifies 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?

Purpose and scope are front-loaded and the sentences mostly earn their place, covering idempotency, cost, and scope. The closing justification ('telling the agent "not this one" is never a paid feature') is slightly rhetorical padding, keeping it from a 5.

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

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

For a mutation tool with no output schema and annotations that only flag it as non-read-only/destructive, the description supplies everything an agent needs: what it does, side effects across surfaces, idempotency, permissions, and cost. Nothing material is missing.

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

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

Schema coverage is 100%, so the baseline is 3; the description adds value by explaining that the reason 'improves what gets ranked next' and that prompt_id/prompt_text together identify the gap. It doesn't explain the enum values, but it clarifies the purpose of the reason parameter beyond the schema's own note.

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

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

States a specific verb+resource ('Set aside one AI visibility (GEO) gap') and defines the object precisely as a tracked question where rivals are named and this product isn't. It explicitly frames itself as 'the same verdict as a skip, on the AI visibility surface,' which separates it from skip_move/archive_move siblings.

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

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

Gives clear context for use — a gap the founder will not act on — and names the analogous sibling concept ('same verdict as a skip') to route the agent. It does not state when to prefer this over archive_move or accept_move explicitly, so it stops short of the full when/when-not/alternative treatment.

Agents often have multiple tools that could apply. Explicit usage 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/destructiveHint=false, but the description adds ordering ('newest first'), cost ('free'), and the exact content categories returned. These extras go beyond the safety profile. It stops short of describing pagination behavior or the per-entry shape, so a 4 rather than 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?

Front-loaded with the core purpose, then supported by the content enumeration and usage directive. The long parenthetical is informative rather than padding, but it is the longest element and slightly delays the usage cue.

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

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

No output schema exists, yet the description enumerates the return contents and ordering, which is what an agent needs to know before calling. It does not cover volume/behavior given the 200-entry cap, but for a simple 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?

Schema coverage is 100% and the single 'limit' parameter is fully documented in the schema (range and default). The description adds no parameter-level detail, so the baseline 3 for schema-complete parameters 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 (the product timeline) and enumerates its contents (drafts, ships, skips, scans, observations, decisions with rationale), which clearly distinguishes it from list-style siblings like list_feed or list_outputs. The poetic framing 'the product timeline' is clarified immediately by the enumeration, so nothing is ambiguous.

Agents choose between tools based on descriptions. A clear purpose with a specific verb 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 an explicit when-to-use directive: 'Read before acting so you never redo recent work.' This is actionable context for sequencing work. It does not name a specific alternative tool or a when-not-to-use condition, keeping 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?

Beyond the readOnly/destructive annotations, the description discloses that strategy is dated judgement rather than measured evidence, that missing facts or strategy return null, and that it is free and never generates or revises a strategy. These are substantive behavioral caveats an agent needs before relying on the data.

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

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

Content is front-loaded with the returned fields, followed by usage and caveats, with no filler sentences. It is dense but every sentence carries information; slight packing of the growth_strategy sub-fields is the only cost.

Shorter descriptions cost fewer tokens and are easier for agents to parse. 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 present, the description carries the burden of explaining return values, and it does so thoroughly by listing both the business fields and the growth_strategy sub-fields, plus null behavior. Nothing material 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?

There are no parameters, so the baseline is 4. The description instead characterizes the returned payload (positioning, ICP, growth_strategy fields with version/source/date), which is useful but not parameter-related.

Input schemas describe structure but not intent. Descriptions should explain 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 (business context) and enumerates exactly what it returns: positioning, audience, ICP, pricing, features, competitors and growth_strategy fields. This is clearly distinguishable from siblings like get_competitors or get_voice_profile.

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

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

"Read before planning or writing" gives a clear usage trigger, and "check it against current founder intent" frames how to treat the data. It does not name specific alternative tools or explicit when-not conditions, so it stops short of a 5.

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

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

Annotations already declare readOnlyHint=true and destructiveHint=false, yet the description adds genuinely new behavior: an empty library is an answer rather than an error, "held" claims are unusable, and every number must travel with its self-critical caveat. These are operational facts the annotations do not cover.

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

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

The content is front-loaded with the resource definition and the imperative to read before citing, then layers in the held/caveat rules. It runs long for a zero-arg read tool and repeats the caveat idea ("the caveat is what makes the number safe to say"), but each sentence carries usable 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?

There is no output schema, so the description must describe the return shape, and it does: each claim carries a sentence, a number with unit, relevance keywords, and a caveat. Combined with the safety annotations and held/empty edge cases, 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?

The tool takes zero parameters, so per the rubric the baseline is 4. There is nothing parameter-side for the description to compensate for, and it correctly omits any argument discussion.

Input schemas describe structure but not intent. Descriptions should explain 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 establishes the resource ("the claim library") and elaborates its contents in detail: a one-sentence claim, a number with unit, keywords, and a caveat. It does not use an explicit verb or name the sibling record_claim as the write counterpart, but the read purpose is unmistakable.

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

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

It gives an explicit when-to-use directive ("READ THIS BEFORE CITING ANY NUMBER about this product") and a hard when-not-use rule ("A claim marked held is NOT for use"). The caveat requirement ("never quote a claim without its caveat") further constrains correct invocation, 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?

Annotations already declare readOnlyHint=true, destructiveHint=false, and openWorldHint=false, so the safety profile is covered. The description adds useful context beyond that: it lists the exact data categories returned (performance, SEO, Core Web Vitals, authority, G2/Product Hunt presence, content freshness, and founder edits) and notes it is 'free.' It does not discuss pagination or rate limits, but with annotations carrying the safety burden this is adequate.

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

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

The description is front-loaded with the resource and its contents, then moves to usage guidance and finally a brief safety/cost note. The first sentence is dense with parenthetical detail but remains readable; overall it is appropriately sized with little 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 carries the burden of explaining return values, and it does so by enumerating the stat battery and founder edits. It also covers when to read the tool and its read-only/free nature. Completeness is strong, though it could mention pagination or sibling alternatives for an even fuller picture.

Complex tools with many parameters or behaviors need more documentation. 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 no parameters, so there is no parameter semantics to document. The baseline for zero parameters is 4, and the description does not need to compensate for any input schema gaps.

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

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

The description names a specific resource (competitor roster) and enumerates the measured stat battery and founder edits it returns, which clearly distinguishes it from siblings like get_seo or get_visibility. It lacks an explicit verb such as 'returns' or 'lists', but the content is specific enough for an agent to know exactly what this tool provides.

Agents choose between tools based on descriptions. A clear purpose with a specific verb 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 to read it: 'before any competitor or outreach work so a rival is never treated as a pitch target.' This is clear contextual guidance, though it does not name alternatives or state when not to use it.

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

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

Annotations already declare readOnlyHint=true and destructiveHint=false, so the 'Read-only' sentence repeats structured data. The description does add behavioral context beyond annotations: 'saved words are not publication proof' warns about interpretation of results, which is genuinely useful. It stops short of describing return format, pagination, or scope.

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

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

At two terse sentences, it is compact and front-loaded. However, the compressed jargon ('source drafts, current move states and X production switch') reads as a list of terms without connective explanation, trading clarity for brevity.

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

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

No output schema exists and the description does not explain what the calendar view contains, how artifacts are organized, or how 'move states' relate to siblings. The warning about publication proof is helpful but leaves major gaps for an agent trying to decide whether to rely on this tool's results.

Complex tools with many parameters or behaviors need more documentation. 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 parameter guidance is not required and the baseline is 4. The description correctly extends no parameter information, and the schema's additionalProperties:false matches the no-args contract.

Input schemas describe structure but not intent. Descriptions should explain 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 concrete artifacts (growth content calendar, source drafts, move states, X production switch) but the density of internal jargon makes the core purpose vague. It is distinguishable from siblings like get_move or get_output, but an agent unfamiliar with the domain cannot form a clear picture of what it returns.

Agents choose between tools based on descriptions. A clear purpose with a specific verb 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 use this tool versus alternatives such as get_move, get_output, or get_activity. The phrase 'Check linkage and calendar_sync' hints at a use case but does not name competing tools or selection conditions.

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

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

Annotations already declare readOnlyHint=true, destructiveHint=false, and openWorldHint=false, so 'Read-only' in the description is largely redundant. It does add cost context ('free', credits only once metering is live), which is behavior beyond the annotations, but the metering sentence is vague and no freshness or failure behavior is described.

Agents need to know what a tool does to the 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 field enumeration is front-loaded and compact, but the trailing fragment 'Credits once metering is live' is cryptic and does not clearly earn its place — it is unclear whether it warns about cost, latency, or unavailable data.

Shorter descriptions cost fewer tokens and are easier for agents to parse. 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 telling the agent what comes back, and it does so by listing the six return fields. For a parameterless read tool this is close to complete, though it omits return format and any indication of when values may be null (e.g., trial_ends_at).

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

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

The tool takes zero parameters, so there is nothing for the description to disambiguate; the baseline for a no-parameter tool is 4. Schema coverage is 100% and empty, so no gap exists.

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

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

The description names the resource concretely — 'the product run summary for this growth engine' — and enumerates the returned fields (product_url, tier, trial_ends_at, timezone, autonomy status, delivery settings), which distinguishes it from siblings like get_scoreboard or get_business_context. The verb is only implied ('get'), so it is clear but not maximally sharp.

Agents choose between tools based on descriptions. A clear purpose with a specific verb 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 such as whoami, get_business_context, or get_setup_snippet. The agent must infer usage from the field list alone; no exclusions or prerequisites 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/destructive/closed-world, and the description adds genuinely new behavioral context: result ordering (newest first) and a semantic caveat that each entry is 'an observation, not a rate,' which affects how an agent should interpret and report the data. It does not describe pagination or result size beyond the limit param.

Agents need to know what a tool does to the 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 clauses, front-loaded with the resource and ordering constraint, with no filler. The phrases 'scoped evidence' and 'observation, not a rate' are terse to the point of being cryptic, costing a little clarity.

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

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

For a read-only list tool with no output schema the description covers behavior and interpretation reasonably well, but it leaves all three input parameters unexplained despite 0% schema coverage, which is a meaningful gap for an agent deciding how to call it.

Complex tools with many parameters or behaviors need more documentation. 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% for all three parameters (limit, idea_id, experiment_id), so the description carries the full burden — yet it never mentions any of them. 'Scoped evidence' vaguely gestures at scoping but does not explain that results can be narrowed by idea or single experiment, or what limit does.

Input schemas describe structure but not intent. Descriptions should explain 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 (growth content experiments already run) and scope (newest first, with scoped evidence), which is enough for an agent to distinguish it from the many other get_* siblings. It lacks an explicit verb in the description itself, relying on the title 'View experiments' for the 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 implies a retrieval use case for past experiments and rules out one misuse ('never runs one'), but gives no conditions for choosing it over alternatives or when to prefer filtering by idea vs experiment. Usage is inferable rather than stated.

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

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

Annotations already declare readOnlyHint=true, destructiveHint=false and closed-world scope, so 'Read-only' largely restates structured data. The one genuinely additive disclosure is 'free' (no cost/quota impact), plus the fact that the full markdown body is returned rather than a summary; not-found or auth behavior is unstated.

Agents need to know what a tool does to the 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, front-loaded with the resource and scope, then the behavioral qualifiers. No filler and nothing a reader must skip past.

Shorter descriptions cost fewer tokens and are easier for agents to parse. 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 return-value burden by naming the full markdown body, and it is complete for a one-param read tool. It stops short of covering failure modes (unknown slug, permission) that an agent might want before calling.

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

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

Schema description coverage is 100% and the schema already explains that the slug comes from list_kb_pages, so the description cannot add much beyond 'by slug'. Baseline 3 is appropriate; no format or validation detail is contributed.

Input schemas describe structure but not intent. Descriptions should explain 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 (fetches one Memory page) and the scope of the payload ('with its full markdown body'), which is exactly what distinguishes it from the sibling list_kb_pages. The added clause about the growth marketing engine drafting from it gives domain meaning without ambiguity.

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

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

Usage is only implied: the slug parameter's schema text points at list_kb_pages, so the pair (list then view) is inferable, but the description itself names no alternative, no when-to-use condition, and no when-not-to-use case.

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

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

Annotations already declare readOnlyHint=true, destructiveHint=false, and openWorldHint=false, so the safety profile is covered. The description still adds real behavioral context beyond that: it distinguishes provisioned-and-enabled loops from runnable_loop_types and states the precondition for a runnable type to actually execute. It does not cover auth or rate limits, but those are minor 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?

Two sentences, front-loaded with the returned content and followed by the clarifying precondition. It is dense but earns its length; only the lack of a leading verb makes the opening slightly harder to parse than ideal.

Shorter descriptions cost fewer tokens and are easier for agents to parse. 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 returns, and it does list the key fields (provisioned loops, autonomy level, runnable_loop_types) plus the runnable precondition. For a zero-required-param read tool with safety annotations already present, this is complete enough; only pagination or response-shape detail is absent, and that is a minor gap.

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

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

Schema description coverage is 100% and the single optional loop_type parameter is documented in the schema with examples (daily_brief, linkedin_post). The description references loop types only generically and adds no filtering syntax or default behavior beyond the schema, so baseline 3 applies.

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

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

The description names the specific resource (automated growth marketing loops provisioned for this product) and enumerates the content returned (autonomy level, runnable_loop_types). It is distinguishable from siblings like get_activity or get_visibility, though it is phrased as a noun phrase rather than an explicit verb+resource, which slightly blunts immediate clarity.

Agents choose between tools based on descriptions. A clear purpose with a specific verb 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 (fetch the state of provisioned loops and what can be run on demand) but there is no explicit when-to-use, when-not-to-use, or named alternative among the many sibling get_* tools. The final sentence explains a state dependency of runnable types rather than when this tool should be invoked.

Agents often have multiple tools that could apply. Explicit usage 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, destructiveHint=false, openWorldHint=false), and the description adds genuine behavioral context beyond them: the meaning of 'Ready' (awaiting review, not published), that 'Closed' post-trial access withholds bodies without asserting absence, and how tracked_link_state explains a null link while null clicks means unreadable. These are non-obvious interpretation rules an agent could not derive from annotations alone.

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

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

The resource identity is front-loaded in the first sentence, then a tight sequence of field-interpretation clauses follows. It is dense and telegraphic without padding; the only near-wasted fragment is 'Read-only, free,' which duplicates the readOnlyHint annotation. Overall well-sized for the amount of semantic nuance it carries.

Shorter descriptions cost fewer tokens and are easier for agents to parse. 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 explaining returns, and it largely does: it enumerates the payload fields (evidence, source material, instructions, prepared_result), flags linked_article as reusable earlier work rather than a completed revision, and pre-empts two common misreadings (null link, null clicks). Error and permission behavior are unstated, but for a single-item read the coverage is strong.

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

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

The schema already documents move_id at 100% coverage, including the 'from list_feed or get_standup' provenance that the description restates. The description adds no format, validation, or null-case detail for the parameter itself. Baseline 3 applies for a single fully documented parameter.

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

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

The description names the resource ('One growth move') and enumerates its contents (evidence, source material, instructions, prepared_result), so an agent can infer this retrieves a single move. However, no explicit verb is given in the description itself — 'view' only appears in the title — and it never differentiates from siblings like list_feed or get_standup beyond the singular/plural implication. Adequate but not 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?

There is no statement of when to call this versus alternatives such as list_feed, get_standup, review_move, or the many mutating *_move siblings. The only routing hint ('from list_feed or get_standup') is a parameter-provenance note that already lives in the schema, not usage guidance. The reader must infer the when-to-use case entirely.

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

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

Annotations already declare readOnlyHint=true, destructiveHint=false, and openWorldHint=false, so safety is covered; 'Read-only' largely repeats that. 'Free' adds a small piece of cost context. The description usefully discloses the shape of the returned payload, but says nothing about freshness, caching, or auth requirements.

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

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

One front-loaded sentence that names the payload before the qualifiers. Efficient, though the four-item list is slightly dense and 'weekly movement scoreboard' could have been trimmed or tied to the sibling it overlaps.

Shorter descriptions cost fewer tokens and are easier for agents to parse. 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 and no parameters, the description does the work of telling the agent what comes back, which it does by enumerating the outcome categories. It stops short of noting freshness or that some sections are empty until moves ship and connections are authorized.

Complex tools with many parameters or behaviors need more documentation. 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 no parameters, so there is nothing for the description to disambiguate; the baseline for a zero-parameter tool is 4.

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

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

States a specific resource and enumerates the returned data: tracked-link clicks per move, shipped counters, weekly movement scoreboard, and connection status for GA4/Search Console. It is distinguishable from most siblings, though the mention of a 'scoreboard' overlaps with the sibling get_scoreboard and no explicit disambiguation is given.

Agents choose between tools based on descriptions. A clear purpose with a specific verb 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 only 'Read-only, free' — it never states when to call this versus get_scoreboard, get_snapshot, or get_activity. No prerequisites, no trigger conditions, no exclusions.

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

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

Annotations already declare readOnlyHint=true, destructiveHint=false, and openWorldHint=false, so the safety profile is covered. The description adds one behavioral detail about SEO linked_article adding the full Markdown article, but does not explain return shape, pagination, or permissions beyond what annotations provide.

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

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

Two short sentences with the core purpose front-loaded. The second sentence about SEO linked_article is slightly cryptic and jargon-heavy, but the overall definition is compact and does not waste 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?

There is no output schema, so the description carries some burden for return-value context. It mentions one optional linked_article expansion, but does not characterize the full draft object an agent should expect, leaving the output shape mostly undocumented.

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

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

Schema description coverage is 100%, and the single parameter is already documented as a uuid in the schema. The description adds no syntax, format, or constraint beyond what the schema provides, so the baseline of 3 is appropriate.

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

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

The description states a specific verb and resource: 'Read a queue draft by id.' The 'by id' scope distinguishes it from the sibling list_outputs, so an agent can tell it retrieves a single known draft rather than enumerating drafts.

Agents choose between tools based on descriptions. A clear purpose with a specific verb 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 'by id' implies the tool should be used when an output UUID is known, but there is no explicit when-to-use, when-not-to-use, or alternative routing (e.g., use list_outputs to find an id first). Usage 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 already declare readOnlyHint=true, destructiveHint=false and openWorldHint=false, so the safety profile is covered; the description reinforces it with 'Read-only, free.' More usefully, it discloses interpretation behavior the annotations cannot: three-state like_for_like semantics (true/false/null) and the rule that a delta must not be reported as a result when like_for_like is not true. It says nothing about latency, rate limits, or data-volume 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?

Front-loaded with the operative question, and the like_for_like caveat is placed where it matters. The middle enumeration ('the moves shipped between them, the scans that ran, and the receipts with what was verified live and the clicks each earned') is prose-heavy and could be tightened, but it earns most of its length by describing return contents.

Shorter descriptions cost fewer tokens and are easier for agents to parse. 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: start/end visibility, moves, scans, receipts, and the like_for_like flag. For a single-optional-parameter, read-only tool this is close to sufficient; only finer return details (ordering, empty-state behavior) are unstated.

Complex tools with many parameters or behaviors need more documentation. 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 window_days already documents its 7-90 range, default of 14, and clamp-never-reject behavior. The description only alludes to 'a period' without adding format or default detail beyond the schema, so the baseline 3 applies.

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

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

Names a specific resource (the growth scoreboard / proof read) and enumerates its scope: AI visibility at the start and end of the window, the moves shipped, the scans that ran, and the receipts with earned clicks. This is distinguishable from adjacent reads like get_visibility or get_outcomes because it is explicitly a period-over-period comparison 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 a strong use condition (reporting whether a change is real, for a period) and an explicit pre-report rule: always read like_for_like first, and never present a delta as a result when like_for_like is not true. It does not, however, name or exclude sibling tools such as get_visibility or get_outcomes, so routing among the several 'get_*' reads is left to inference.

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

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

Annotations already declare readOnlyHint=true and destructiveHint=false, so 'Read-only' is largely redundant; 'free' is the one genuinely new behavioral fact. The description enumerates returned sections, which helps set expectations, but says nothing about pagination, freshness, or rate limits.

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

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

Front-loads the audit contents, then the usage condition, then the parameter hint — a sensible priority order. It is dense but every clause carries information; only the redundant 'Read-only' slightly dilutes 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?

No output schema exists, so the description correctly carries the burden of describing return shape, and it does so in detail. The behavioral safety profile is covered by annotations, so the remaining gaps (pagination, data freshness) are minor for a read-only single-parameter 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?

With a single parameter at 100% schema coverage, the schema already carries the semantics. The description's 'Pass include_pages for the per-page detail' restates the schema's default-false behavior rather than adding format or depth information beyond it.

Input schemas describe structure but not intent. Descriptions should explain 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 ('site-wide SEO audit') and then enumerates the concrete payload: issue groups with severity, weekly score trend, page performance, links/authority, day-0 ranks. This clearly separates it from siblings like get_visibility or get_competitors.

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

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

Gives explicit ordering guidance ('Read before any SEO work of your own') and a downstream dependency ('the Feed seo_fix moves are minted from it'), which tells the agent when to reach for this tool. It stops short of naming a competing sibling or a when-not-to-use condition.

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

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

Annotations already declare readOnlyHint, destructiveHint=false and openWorldHint=false, so 'Free, read-only' is largely redundant. The description does add useful content-scope context (which topics the snippet covers, that it flags paid tools), but nothing about format, length, or return shape.

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

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

The key deliverable is front-loaded in the first clause, followed by scope and usage guidance. The second sentence is dense with enumerations but each item earns its place; slightly long, though not wasteful.

Shorter descriptions cost fewer tokens and are easier for agents to parse. 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 convey what comes back — and it does, describing the snippet's purpose and coverage. It stops short of describing format or how to detect success, which would fully close the gap for a no-arg retrieval tool.

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

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

Zero parameters, so per the rubric the baseline is 4. There is no parameter semantics to add meaning to.

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

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

States a specific resource — the paste-able 'Growth (AfterLaunch)' section for CLAUDE.md/AGENTS.md — and enumerates the subject matter it covers. No sibling tool overlaps with this output, so the agent can identify it immediately.

Agents choose between tools based on descriptions. A clear purpose with a specific verb 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 usage direction ('Show it to the founder and add it with their say-so') and the context in which it applies (agent setup). It does not name alternatives, but none exist among the siblings for this specific artifact, so the lack of exclusions is minor.

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

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

Annotations already declare readOnlyHint=true, destructiveHint=false and openWorldHint=false, so the description's "Read-only" largely restates structured data. It does add genuinely new context — "free" (no cost) and the stable-vs-live distinction, which is a behavioral trait about data freshness not covered by any annotation. That earns partial credit but not a high score on its own.

Agents need to know what a tool does to the 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 payload contents and closed with the stable-vs-live qualifier. It is dense but every clause describes an actual field of the snapshot, so nothing is wasted; the long comma list is slightly harder to scan than a bulleted form but acceptable.

Shorter descriptions cost fewer tokens and are easier for agents to parse. 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 and no parameters, the description carries the burden of telling the agent what it gets back, and it does so thoroughly by enumerating the snapshot's contents. Combined with the free/stable qualifiers, an agent has enough to decide and call correctly; only the explicit relationship to live-signal siblings is missing.

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

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

The tool takes zero parameters, so there is no parameter semantics for the description to clarify; the baseline for a parameterless tool is 4. Nothing here misleads about inputs.

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

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

The description concretely enumerates what the snapshot contains (positioning, discoverability score, prioritised actions, competitor set, day-0 SEO/AI baselines), which is far more specific than the title. It also implicitly distinguishes itself from live-signal siblings like get_seo or get_visibility by framing this as stable baseline context. It stops short of a clean verb+resource statement and never names a sibling, so it lands just under 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 stable business context, not live signal data" gives an implied selection rule against live-data tools, which is useful. However, it never names the alternatives (get_seo, get_visibility, get_business_context) or states explicitly when an agent should fetch this rather than those. 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 declare readOnlyHint and destructiveHint=false, so safety is covered; the description adds genuinely new traits beyond them: the 7-day window for while_you_were_gone, that it is capped at account age, that rank reflects position among all moves and gaps mean unshippable ranks, and that the tool is 'free.' The 'Relay the message field' instruction is a useful behavioral directive.

Agents need to know what a tool does to the 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 and each parenthetical clause introduces a distinct return component rather than restating. It is dense as a single long sentence, but every clause (receipts, ready, while_you_were_gone, deep scan status) carries information the agent needs, 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 burden of describing the return shape and does so thoroughly: it names the standup sections, explains the rank semantics of 'ready,' and flags the message field to relay. Combined with the annotations covering the safety profile, an agent has enough to call and use it correctly.

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

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

The tool takes zero parameters, so per the baseline a 4 applies. There is no input to misdescribe, and the schema takes no input names to explain.

Input schemas describe structure but not intent. Descriptions should explain 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, recognizable artifact (the daily growth marketing standup) and enumerates exactly what it aggregates: receipts, ready moves, while_you_were_gone, and deep-scan status. This clearly distinguishes it from the many granular siblings like get_activity, get_outcomes, and get_scoreboard, which it consolidates 'in one call.'

Agents choose between tools based on descriptions. A clear purpose with a specific verb 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 framing 'in one call' strongly implies this is the preferred aggregate over calling the individual sibling tools separately, giving clear context for use. However, it never explicitly names an alternative or a when-not condition (e.g., when to prefer get_scoreboard directly), so it stops short of full routing 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/openWorldHint/destructiveHint, so the safety profile is covered. The description adds genuinely useful context beyond that: every reading carries its own sample count, and a change should be treated as indicative unless the sampling block licenses otherwise. That interpretive caveat is real behavioral guidance for reading the output, though pagination/limits are not discussed.

Agents need to know what a tool does to the 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 primary content is front-loaded in the first sentence, followed by the interpretation caveat and then the parameter tip. It is dense but each clause carries content; the only mild cost is the run-on enumeration in sentence one, which is long but not wasteful.

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

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

With one optional parameter, no nested objects and no output schema, the description carries the burden of conveying what comes back, and it does so thoroughly, including the sampling caveat for interpreting changes. Nothing essential is missing for a read-only reporting tool.

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

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

Schema coverage is 100% and the lone parameter's schema description already spells out the drill-down behaviour ('Drill into one tracked question by its id (from the prompts list) for the engine answer text and citations'). The description's 'Pass prompt_id to drill into one question' largely restates that, adding no new meaning. Baseline 3 applies.

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

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

The description names a specific resource and enumerates its contents concretely: engine answers (ChatGPT, Gemini, Perplexity, Google AI Overviews), share of voice, cited sources, competitor-owned gaps, trend, crawlability and off-site reach. An agent knows exactly what data comes back. It does not, however, explicitly contrast itself with near-neighbours like get_scoreboard, get_seo or get_snapshot, 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 only operational instruction is 'Pass prompt_id to drill into one question', plus the meta note that it is read-only and free. There is no statement of when to reach for this tool versus the sibling reporting tools, and no exclusions or prerequisites. Usage 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 already declare readOnlyHint and destructiveHint=false, so the safety profile is covered; the description reinforces this and adds genuinely new behavioral context — that a false has_profile is a legitimate empty state, not a failure, and that the three registers are semantically distinct. No return format detail, but annotations carry the safety burden.

Agents need to know what a tool does to the 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 definition of the resource, then handles the register semantics and the false-state case. Dense but each clause carries information; slightly long but no obvious 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 compensates by listing the profile's components and explaining the empty-state behavior, which is what an agent needs to interpret a call. Complete enough for a single-optional-param read 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 baseline is 3, but the description goes beyond the schema by defining each enum value's provenance (brand = website's voice, personal = founder's writing, imported = from a brief) and noting they do not sound alike — meaningful semantics the enum list alone doesn't 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 (read/view) and resource (the structured voice profile) and enumerates exactly what it contains: tone, characteristic phrases, vocabulary, sentence style, and avoided patterns. An agent can distinguish this from siblings like set_voice_axes or record_voice_rule 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?

Gives clear usage context for the register parameter (omit for current, use 'personal' for founder posts) and clarifies the has_profile=false case as a valid answer rather than an error. It does not explicitly point to alternatives such as set_voice_axes for writing a voice, so it falls short of full when/when-not 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 declare readOnlyHint=true and destructiveHint=false, but the description adds genuinely new context: each row returns one of connected/not_connected/not_available plus the reason an integration is disabled on this account, and that reads are free. That is real behavioral value beyond the structured fields.

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

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

Front-loaded with the resource list and the state semantics; every sentence carries information. Slightly padded with framing like 'the measurement behind SEO and outcomes' and 'honest state', which is flavor rather than instruction.

Shorter descriptions cost fewer tokens and are easier for agents to parse. 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 compensates by spelling out the possible per-row states and that a reason accompanies not_available, which is exactly what an agent needs to interpret the response. Missing only the row field names for machine parsing.

Complex tools with many parameters or behaviors need more documentation. 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 no parameters, so the schema carries nothing to document and the description needs only to confirm a no-argument call, which it implicitly does. Baseline 4 for zero parameters applies.

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

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

Names a specific verb+resource (listing connections) and enumerates exactly which sources are covered — GA4, Search Console, Google Business Profile, LinkedIn/Reddit — so an agent can distinguish it from start_connection, poll_connection and disconnect_connection at a glance.

Agents choose between tools based on descriptions. A clear purpose with a specific verb 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 'Read-only, free' implies this is the safe discovery call, but there is no explicit when-to-use or routing versus poll_connection/start_connection/disconnect_connection. Usage 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 already cover readOnly/destructive/openWorld, and the description confirms 'Read-only' plus adds real context beyond them: the material BODY is absent, live moves only by default, and compact verbosity omits bodies to keep long lists cheap. It does not discuss rate limits or pagination, but the filtering defaults are well 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 dense and front-loaded, leading with what the backlog contains before the caveats about filtering and the missing body. Slightly long, and 'Read-only' duplicates the annotations, but nearly every clause carries information.

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

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

With no output schema, the description carries the return-shape burden and does so by enumerating the fields and posture values, plus flagging that bodies are excluded. An agent could call it correctly, though the exact response shape and ordering guarantees are only partially specified.

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

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

Schema description coverage is 100%, so the schema already documents since, verbosity, and include_resolved thoroughly. The description's field-level prose (has_draft, draft_kind, posture) describes return values rather than adding meaning to the parameters themselves, 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 ('the ranked backlog of growth marketing moves') and enumerates the fields returned (title, why, area, status, rank, has_draft, draft_kind, posture). It is clearly distinguishable from siblings like get_move, replenish_feed, or get_content_calendar.

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

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

It gives explicit context ('read it before improvising growth work of your own') and states the conditions for include_resolved and since. It does not name alternative tools for fetching a single move or the missing body material, so routing is implied rather than explicit.

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

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

Annotations already declare readOnlyHint=true, destructiveHint=false, and openWorldHint=false, so safety is covered. The description adds behaviorally relevant context beyond that: the listing returns summaries plus a size hint rather than full content, and the operation is 'free' (no cost/credit implication). It does not mention pagination or ordering, which is a minor residual 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 short fragments with no wasted words; the resource definition is front-loaded and the 'summaries with a size hint' detail is useful. The parenthetical content list is dense but earns its place by clarifying what a Memory page 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?

For a zero-parameter, read-only list tool with no output schema, the description covers what the resource is, what the listing yields (summaries + size hint), and the read-only/free nature. Only pagination or result-count behavior is left unspecified, which is a small gap given the tool's simplicity.

Complex tools with many parameters or behaviors need more documentation. 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 per the rubric the baseline is 4. The schema is empty and needs no compensation, and the description correctly implies no input is required.

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

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

The description names a specific resource (Memory pages / kb pages) and states what the listing contains (summaries with a size hint), which distinguishes it from the sibling get_kb_page that retrieves a single page. The verb 'list' comes only from the tool name and the fragmentary sentence structure makes the purpose slightly less immediate than a clean verb+resource statement.

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

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

Usage is only implied: an agent can infer this is the enumeration entry point versus get_kb_page for a single page, but the description never says when to use it or names the alternative explicitly. 'Read-only, free' adds a small usage signal but is not routing 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 cover readOnly/destructive/openWorld, and the description reinforces this while adding genuinely new context: 'newest first' ordering and the fact that the call is 'free' (no cost/quota). It stops short of describing pagination or result limits.

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

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

A single compact sentence that leads with what the tool lists and then the ordering and field set. Dense but nothing wasted; the trailing 'Read-only, free' is a terse and useful tag.

Shorter descriptions cost fewer tokens and are easier for agents to parse. 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 (id, loop_type, kind, status, title) and the sort order. Only pagination/result-count behavior is unaddressed, a minor gap for a no-arg 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 takes zero parameters, so the baseline is 4. The description correctly conveys that no filtering arguments exist and instead enumerates the fields of the returned records.

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

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

Names the specific resource ('drafted marketing and distribution content produced for this product') and its ordering, so an agent knows exactly what list it returns. It doesn't explicitly distinguish itself from the singular get_output sibling, which keeps it 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?

Usage is implied by the resource description — you call this to enumerate drafts, get_output to fetch one. There is no explicit 'use this when / not when' or reference to alternatives such as get_output or list_queue.

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

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

Beyond the readOnly/non-destructive annotations, the description adds genuinely useful behavioral facts: the sort order, that attempt_id is nullable, that prepared_content is deliberately excluded from queue summaries, that the call is free, and that the 'act' scope is required. These are exactly the details an agent cannot infer from the schema or 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 short sentences, each carrying distinct information — scope/ordering, row shape, exclusion and cost. Nothing is redundant and the most important fact (what the queue is) 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 parameters and no output schema, the description must carry the return shape, and it does (job_id, attempt_id, no prepared_content). It stops short of mentioning pagination or typical queue size, a minor gap for a 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 takes zero parameters, which establishes the baseline of 4. The description correctly adds no parameter guidance because there is nothing to describe, though it does describe the shape of returned rows, which is adjacent value.

Input schemas describe structure but not intent. Descriptions should explain 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 precisely ('Unclaimed preparation jobs'), adds ordering ('oldest first'), and specifies row contents (job_id, nullable attempt_id). It implicitly distinguishes itself from claim-oriented siblings like pick_up_job, but never names a sibling explicitly, so it falls just short of the top tier.

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

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

'Free; requires the act scope' gives cost and auth preconditions, which is more than nothing, but there is no statement of when to use this versus pick_up_job or get_loop_status. Usage is implied rather than directed.

Agents often have multiple tools that could apply. Explicit usage 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, destructiveHint=false, openWorldHint=false), so the bar is lower. The description adds genuinely new behavior: results come back in tracking order, include a hard cap of 15 and a used count, and curated:false means the prompts were system-generated and replaceable. That is real return-shape disclosure not present in any structured field.

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

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

Front-loaded with the resource definition, then the return details, then plan/safety context. Sized well for a no-arg list tool. Minor redundancy: 'Read-only' restates readOnlyHint=true, which the structured annotations already carry.

Shorter descriptions cost fewer tokens and are easier for agents to parse. 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 must carry the return-shape burden, and it does: ordering, the hard cap of 15, the used count, and the curated flag. Slightly more on what a prompt record contains (base question text, timestamps) would make this fully self-contained.

Complex tools with many parameters or behaviors need more documentation. 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 baseline is 4 by rule. The description correctly does not waste space documenting non-existent inputs and instead spends its words on output semantics.

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

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

States a specific resource and scope: 'the customer questions AfterLaunch tracks: the AI visibility (GEO) question set every measurement is taken against.' An agent can identify what the tool enumerates. It does not explicitly contrast itself with the sibling mutators (track_prompt / untrack_prompt), so it falls short of a 5.

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

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

Usage is only implied — the read-only, free-on-every-plan framing suggests safe inspection, but the description never says when to call this versus track_prompt, untrack_prompt, or the other list_* tools. No exclusions or prerequisites 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 flag it as a non-read-only, destructive, closed-world operation. The description goes further: it discloses the authorization requirement ('act' scope), the cost ('Free'), and crucially the claim semantics and response contract (claim_won:true, non-winner on unchanged result) that govern whether downstream work may start. It doesn't explain failure/conflict handling or concurrency edge cases, 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?

Five short sentences, front-loaded with the action and its argument source, then the proceed/no-proceed rule, then cost and auth. Every sentence carries a distinct operational fact 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?

With no output schema, the description carries the response burden and does partially: it names claim_won:true as the success signal and defines the non-winner case. However, it doesn't describe other possible response fields or error/conflict outcomes for a claim-style operation, leaving a small gap for an agent deciding how to react to a failed pickup.

Complex tools with many parameters or behaviors need more documentation. 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 required params and both optionals are already documented in the schema. The description reinforces the exactness of attempt_id ('the exact nullable attempt_id') and its null-only-for-legacy nuance, but adds no syntax or format detail beyond what the schema provides. 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 — 'Try to claim one queued preparation attempt' — and pins it to a concrete workflow by naming list_queue as the source of job_id/attempt_id. An agent can distinguish this from sibling list_queue (read-only listing) and report_job 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?

Gives a clear operating condition: only start work when the response says claim_won:true, and an unchanged result must not start work. It also routes the agent to list_queue for the required ids. It stops short of naming explicit alternatives or a when-not-to-use case, so it's strong context rather than a full decision matrix.

Agents often have multiple tools that could apply. Explicit usage 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, and the description adds genuinely new context: idempotency ('nothing is spent or consumed') and the full enumeration of possible outcomes with their handling. This goes beyond repeating the safety flags, though it doesn't cover rate limits or response format detail.

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

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

Front-loaded with the governing question, then the required argument, then the outcome enumeration in a single compact flow. Every sentence carries actionable information 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?

There is no output schema, so the description bears the burden of return values and it does so well by listing pending/connected/expired/not_found with handling hints. The only gap is that the poll_after_seconds value referenced for pending is not explained as coming from 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?

With one parameter at 100% schema coverage the baseline is 3; the description adds real meaning by clarifying that the poll_token is the one received with the link, matching the schema's note that it comes from start_connection.

Input schemas describe structure but not intent. Descriptions should explain 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: it asks whether the founder finished connecting a growth data source and polls for that state. It clearly distinguishes from siblings like start_connection, list_connections, and disconnect_connection by framing itself as the status check for a link already handed out.

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

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

It gives clear context for use (after handing over a link, pass the poll_token) and per-outcome next steps for pending, expired, and connected. It doesn't explicitly name the alternative tools (start_connection to mint a fresh link), leaving that to inference, so it falls short of a 5.

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

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

The description goes well beyond the annotations: it documents dedup behavior ('a repeat ... hands back the existing move id'), the draft_only posture for Reddit/Hacker News, the requirement of user consent before posting, that outreach sends from the user's address, and that the call is free, needs 'act' scope, and is rate-limited daily. It doesn't state reversibility or failure modes, but the disclosure is 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?

Front-loaded with the core action, then structured by 'WHEN:' and 'WHAT COMES BACK:' labels. It is dense and the WHEN sentence runs long, but nearly every clause carries operational information and nothing is 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 supplies the return contract ('the move id and posture'), the posture semantics, the cost/scope/rate-limit profile, and the trigger conditions. An agent has everything needed to call this correctly without further lookups.

Complex tools with many parameters or behaviors need more documentation. 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; however the description adds meaning the schema doesn't, mapping kind values to behavioral consequences (Reddit/HN targets become draft_only) and clarifying that duplicate detection keys on kind+target or kind+title, which sharpens how 'title' and 'target' are used.

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

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

The first sentence names a specific verb and resource with state ('Add a pending move'), which cleanly separates it from sibling mutators like accept_move, ship_move, and archive_move. The agent can tell this creates a proposal rather than acting on an existing one.

Agents choose between tools based on descriptions. A clear purpose with a specific verb 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 'WHEN:' clause enumerates concrete triggers (a found community thread, a placement ask, outreach, a directory listing, a page for their site) and pairs them with an explicit exclusion: 'and no move covers it yet.' This is genuine when-to-use and when-not guidance with no inference required.

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

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

Adds substantial behavior beyond the annotations: cost ('Free'), required auth scope ('act'), and dedup/replacement semantics ('Recording the same claim twice replaces your earlier wording; a pinned claim is left as it is'), which directly explains the destructiveHint=true. It also states the return payload ('top moves with move ids').

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

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

Four tight sentences using WHEN / Never / WHAT COMES BACK structure, front-loaded with the record action and its purpose. Each sentence carries distinct load — purpose, eligibility, exclusions, side effects, return — with no filler.

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

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

For a destructive-record tool with no output schema, it covers everything an agent needs: cost, scope, exclusions, replacement behavior, and the return shape. There is no output schema, and the description compensates by describing what comes back.

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

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

Schema coverage is 100%, so the baseline is 3, but the description adds a real semantic constraint by insisting the NUMBER and its caveat be recorded together ('a number without its caveat is what this library exists to prevent'). It does not address the 'held' or 'trigger' parameters, so it stops short of a 5.

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

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

Specific verb+resource ('Put one measured number ... into the claim library') with an explicit scope qualifier (one number, measured, founder-defensible). It clearly separates itself from read-side siblings like get_claims and from the other record_* tools by naming the claim library and the measurement requirement.

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

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

Explicit WHEN clause (a real measurement lands and the founder would defend it in public) plus a hard when-not list: never estimates, projections, rival figures, or inferences. Nothing is left to inference about applicability.

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

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

Annotations already declare a mutating, destructive, non-open-world tool, and the description adds real context beyond them: it requires the 'act' scope, performs no spend or posting, keeps evidence holds, does not authorise drafting, requires run_key to stay stable (idempotency) and expected_updated_at to be passed unchanged (optimistic concurrency). That is meaningful disclosure the annotations cannot carry.

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

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

The leading clause is front-loaded with the main verb, which is good, but the first sentence buries a parenthetical inside a parenthetical ('desk: a post, reply or task ... due_on a date') that is hard to parse. Length is moderate and largely earns its place, yet the structure is a run-on rather than cleanly grouped per operation.

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

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

For a 14-parameter, deeply nested mutation tool with no output schema and only three sparse annotations, the description covers the operation-specific requirements and idempotency/concurrency contract well. It still leaves several parameters and the research sub-object's required fields unexplained, so an agent would have to infer field-level semantics from the schema alone.

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

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

Schema description coverage is 0%, so the description must carry parameter meaning, and it covers much ground — channels, kind, score, final_text verbatim, desk/slot_at/due_on, source_idea, action_kind, idea_id, source_url, run_key, expected_updated_at, adopt_legacy. But top-level 'why', 'text', 'title', 'channel', 'claim_ids', and the research object's required fields are never explained, so a large share of the 14 params remains undocumented in both places.

Input schemas describe structure but not intent. Descriptions should explain 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 ('File') and resource set — a growth idea, an original X draft, or a research outcome — which maps to the operation enum and distinguishes it from read-side siblings like get_content_calendar. The parenthetical stuffing and nested clauses blur the core purpose somewhat, but an agent can still identify it as the writer for content artifacts.

Agents choose between tools based on descriptions. A clear purpose with a specific verb 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 conditional guidance for individual operations ('Research appends a result to its idea', 'Drafts need action_kind social_post and one idea_id or source_idea', 'adopt_legacy only reclassifies an exact saved replay'). However it never states when to pick this over sibling writers such as update_draft, redraft_output, or set_output_status, so alternative selection is left 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 declare destructiveHint=true, readOnlyHint=false and openWorldHint=false; the description goes beyond that with dedupe semantics ('recording the same insight twice replaces your earlier note; a pinned note is left as it is'), the fact that it is free, the required 'act' scope, and what the call returns. Only the exact irreversibility of an overwritten unpinned note is left slightly implicit.

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

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

Well front-loaded: purpose first, then WHEN, then exclusions, then mechanics and return value. Some clauses are motivational rather than operational ('Recording it is part of the job, not a favour'), which costs a little density but does reinforce the tool's importance.

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

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

There is no output schema, and the description compensates by describing the response ('their top moves with move ids, so recording hands you your next instruction without a second call'). With three params, dedupe behavior, scope, and cost all covered, an agent has everything needed to call this correctly.

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

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

Schema description coverage is 100%, so the meaning of kind, insight, and source_move_id is already fully documented in structured data. The description mostly restates those constraints (one sentence in the founder's own terms, 10 to 500 characters) without adding new format or syntax guidance, so a 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 plus resource ('write one durable thing you have learned ... into AfterLaunch's Memory') and explains the consequence of the write (drafts are written from Memory). It also routes the reader away from a near-sibling by noting that an approved writing rule belongs in record_voice_rule rather than here.

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

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

Explicit WHEN clause ('the moment the founder tells you something that will still be true next month and that AfterLaunch could not have measured itself') plus a concrete negative list: never record chatter, a passing mood, a restatement of the Snapshot or Memory, or anything inferred rather than heard. Alternatives (record_voice_rule) and the cost/scope prerequisite are named too.

Agents often have multiple tools that could apply. Explicit usage 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 a destructive, open-world write; the description adds real context beyond them: idempotent replace semantics ('a new address replaces the old one, the same address again changes nothing'), a host validation constraint, no cost, and the required 'act' scope. These are exactly the mutation details an agent needs and they are consistent with destructiveHint=true.

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

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

Purpose is front-loaded and the WHEN/WHAT COMES BACK labels make it scannable. It is dense but every clause carries information; the only mild cost is the slightly crowded single-paragraph delivery.

Shorter descriptions cost fewer tokens and are easier for agents to parse. 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 states what returns ('every profile on record, the new one marked'), and for a destructive, scope-gated mutation it discloses replacement semantics, validation rules, cost, and auth scope. Nothing an agent needs to call it correctly is missing.

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

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

Schema coverage is 100% (baseline 3), and the description adds genuine meaning: the per-site uniqueness rule and the requirement that the address sit on the site's own host, which constrain the url parameter beyond its schema text.

Input schemas describe structure but not intent. Descriptions should explain 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 ('File one public profile or listing') and a precise resource, plus the downstream effect ('counts it as a verified presence'). The resource named (a directory-site profile) is clearly distinct from sibling record_* tools that handle claims, content, insights, and voice rules.

Agents choose between tools based on descriptions. A clear purpose with a specific verb 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 an explicit WHEN condition ('you opened the page and it is theirs') along with operating rules (one address per site, replacement behavior). It does not name alternatives or when-not conditions, so it sits below a full routing statement.

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

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

Annotations already declare write/destructive/open-world=false, and the description adds real value beyond them: it states the rule is free, requires the 'act' scope, and describes downstream effects (morning marketing posts, move and voice reads, visibility in Memory). It does not, however, address the destructiveHint=true flag – whether recording a rule can overwrite or conflict with existing rules is never 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?

Front-loaded with the core action and scope boundary, then the WHEN gate, then constraints and cost. Dense and mostly waste-free, though the sentence listing downstream surfaces ('move and voice reads carry it') is the one place phrasing is heavier than needed.

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

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

For a one-parameter write tool with an output schema absent and annotations present, the description covers trigger, scope requirement, cost, and effects. The remaining gap is the destructive/replacement semantics flagged by the annotations, which an agent should know before writing.

Complex tools with many parameters or behaviors need more documentation. 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 'text' parameter, so the baseline is 3. The description adds a constraint not in the schema's own enum/form: 'One sentence. At most 12.' (presumably words), tightening the loosely bounded 10–200 char limit, though the unit of '12' is left slightly ambiguous.

Input schemas describe structure but not intent. Descriptions should explain 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 (save a writing rule) and immediately draws the scope boundary that matters: into the person's OWN voice, never the brand's. That distinguishes it from siblings like set_voice_axes and get_voice_profile, which operate on the brand voice.

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

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

Explicit WHEN clause: only after the person approves it in words, with a concrete example (a yes to a rule proposed from how they edited a draft) and an explicit exclusion (never record one they did not approve). There is no ambiguity about the trigger condition.

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

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

Goes well beyond the annotations (which only give destructiveHint=true, readOnly=false, openWorld=false). It discloses validation behavior (unfilled placeholders and broken links are refused), reversibility (previous draft kept as revision history), cost (free), and authorization requirements ('act' scope, Founder tier). This is exactly the extra context an agent needs before mutating.

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

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

Three sentences, front-loaded with the action and staged from purpose to constraints to cost/auth. Every sentence carries new information with no repetition.

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

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

No output schema exists and this is a destructive mutation, yet the description covers validation rules, history retention, cost, and scope requirements. The only unaddressed area is the conflict/refresh flow, which is partially handled by the schema's draft_fence description.

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

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

Schema description coverage is 100%, so all three parameters including the nested draft_fence object are already documented in the schema. The description adds no syntax, format, or constraint 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?

Names a specific verb (replace) and resource (a drafted marketing output's body) with scope ('before it is shipped'). It differentiates behaviorally from the AI-redraft flow via 'Manual replacement only', but never names the obvious sibling update_draft, so routing still requires inference.

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

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

'before it is shipped' and 'Manual replacement only: the AI redraft stays in the app' establish clear context and an implicit exclusion against the automated path. However, it does not explicitly name update_draft as the alternative or state when-not to use this tool.

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

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

Annotations already flag a destructive, open-world write operation, and the description adds substantial operational context: it spends money, requires write scope, depends on credit and tenant caps, and explains same-day idempotent replay behavior. This is exactly the kind of cost and rate-limit disclosure an agent needs before invoking.

Agents need to know what a tool does to the 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 cost warning is front-loaded, and the remaining sentences each add a distinct constraint: scope, plan requirement, idempotency, caps, and same-day replay behavior. There is no wasted text despite the dense operational detail.

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

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

For a paid, destructive, open-world mutation tool, the description covers permissions, billing, limits, and idempotency thoroughly. Since no output schema exists, it could say more about what the scan returns or whether execution is async, leaving a minor completeness gap.

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

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

Schema description coverage is 100%, so the baseline is 3, but the description adds useful semantics about the idempotency key and the fact that same-day repeats replay the original result regardless of the key. It still largely echoes the schema's enum and key details, so it does not reach 5.

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

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

The description states a specific verb and resource: 'run an on-demand AI visibility scan (scan=ai_visibility)', and clarifies it is a GEO measurement. It does not explicitly distinguish this paid scan action from sibling read tools like get_visibility or get_scoreboard, so it is clear but lacks sibling differentiation.

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

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

It gives clear usage context by stating this is an on-demand paid scan requiring write scope and a paid plan or active trial. It also explains daily caps and same-day replay behavior, but it does not name alternatives or when-not-to-use conditions.

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

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

Beyond the annotations (destructiveHint=true, openWorldHint=true), the description discloses the cost model ('SPENDS MONEY'), credit-balance bounding, per-tenant daily/monthly caps, the once-a-day-per-product limit, and the required write scope and plan tier. This is unusually rich behavioral context for a mutation tool.

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

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

Three sentences, front-loaded with the critical 'SPENDS MONEY' warning, then requirements, then limits. Every sentence carries distinct, load-bearing information with no waste.

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

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

No output schema exists, and the description compensates fully by covering cost, scope requirements, plan eligibility, rate limits, and the money-spending consequence. Nothing an agent needs before invoking a paid mutation 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 idempotency_key parameter is fully documented in the schema, so the schema already carries the semantics. The description's mention of minting a key restates rather than extends it, so the baseline 3 applies.

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

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

States a specific verb+resource: 'run the growth-move generator on demand to top up the Feed with fresh marketing moves.' It names the content domain (SEO, AI visibility, competitors, distribution) and is clearly distinguishable from read siblings like list_feed or get_move.

Agents choose between tools based on descriptions. A clear purpose with a specific verb 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 invocation ('on demand', 'once a day per product') and prerequisites ('write' scope, paid plan or active trial). It does not explicitly name an alternative or say 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 declare this is a write (readOnlyHint=false, destructiveHint=true), and the description adds value beyond them: the 'act' scope requirement, the fact that planned_url/published_url are checked by the system, and that ready_for_review is repeatable until the user consumes it. It does not explain what the destructiveHint actually destroys, which keeps it short of 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?

Front-loads the core verb and the attempt_id requirement, then walks the state list. It is dense and semicolon-chained but nearly every clause carries a distinct constraint; the thread/screenshot aside is slightly tangential but still operational.

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

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

For a 12-parameter write tool with no output schema, the description covers state semantics, required companions, auth scope, and verification behavior. The main omission is any statement of what the call returns or what the destructive action affects.

Complex tools with many parameters or behaviors need more documentation. 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 92%, so the baseline is 3, but the description goes further by binding parameters to states ('shipped with the live published_url, or planned_url once merged') and clarifying asset_url's meaning ('when your user must post it or when it is the pull request you opened'). That adds real semantics beyond the schema text.

Input schemas describe structure but not intent. Descriptions should explain 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 ('Report a claimed attempt with its exact attempt_id') and enumerates the state transitions it can record. It clearly distinguishes itself from read-side siblings like list_queue/get_loop_status, though it does not name any sibling explicitly.

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

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

The state-by-state enumeration effectively tells the agent which payload each mode requires, which is real usage guidance. However there is no explicit when-to-use/when-not framing or routing to alternatives (e.g., set_output_status, ship_move), so the 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?

Beyond the annotations' destructiveHint/openWorldHint, the description discloses the concrete destructive effect (prepared or failed result set aside), the side effect (new preparation attempt), the boundary 'This never publishes anything', the cost ('Free'), and the auth requirement ('act' scope). This is meaningfully more than the structured fields provide.

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

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

The core effect is front-loaded in the first clause, followed by short, scannable sentences covering the ID requirement, non-publication, cost, and scope. It is dense but largely waste-free; the phrase 'only if this wins' is the one ambiguous bit.

Shorter descriptions cost fewer tokens and are easier for agents to parse. 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 effect, safety boundary, cost, and auth scope, and annotations carry the safety profile. What remains thin is the precondition named awkwardly as 'only if this wins' and the absence of any post-call state or failure expectation.

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

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

Schema coverage is only 25%, so the description must carry weight. It adds useful semantics for two IDs ('Pass the exact job_id and expected_attempt_id'), implying an optimistic-concurrency guard echoed by the schema's 'exact current managed attempt', but it says nothing about move_id or the optional note, leaving half the parameters unexplained.

Input schemas describe structure but not intent. Descriptions should explain 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 ('revise an accepted growth move's current managed attempt') and describes the concrete effect: the prepared or failed result is set aside and a new preparation attempt starts. This clearly separates it from siblings like accept_move, adopt_move_result, undo_move, and redraft_output, which imply different outcomes.

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

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

It states the triggering condition ('Apply your user's explicit decision') and the gating constraint ('only if this wins'), giving clear context for when it applies. However, it names no alternative tool for the other branches and never explains when NOT to use it, so it stops short of full routing 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 only flag destructiveHint=true/readOnlyHint=false; the description adds real behavioral context beyond that: it never posts to a channel, publishing is a separate human-approved egress step, it is free, and it requires the 'act' scope and Founder tier. It also warns against reporting a draft that did not actually go out. No conflict with the destructive annotation, which is consistent with dismissing/settling a queue record.

Agents need to know what a tool does to the 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 purpose followed by a WHEN block is a good structure, and every part is relevant. There is mild redundancy, though: the no-publishing guarantee is stated twice and the 'not optional' motivation is a second sentence of exhortation rather than new operational 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 3-param, two-action resolution tool with no output schema, the description covers everything an agent needs: what each action resolves, when to call each, that it does not publish, the permission prerequisites, and the accuracy constraint on final_text. Nothing material is missing.

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

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

Schema coverage is 100%, so the baseline would be 3, but the description meaningfully reinforces 'final_text': only the words actually posted, never a rewrite or the draft, used solely to learn voice, and omittable when unknown. That adds intent and edge-case guidance (do not fabricate the posted text) beyond the schema's field text.

Input schemas describe structure but not intent. Descriptions should explain 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: resolving one drafted marketing output in the founder's review queue, with the two concrete actions ('ship', 'skip') and what each does. It is clearly distinguishable from near-neighbors like ship_move/skip_move (moves) and from publishing tools, since it explicitly says resolution does not publish.

Agents choose between tools based on descriptions. A clear purpose with a specific verb 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 an explicit WHEN block: call 'ship' the moment the founder confirms content is out, with their go and never on your own; call 'skip' when they decide against it. It also separates the agent's job (reporting) from the human's (posting), so the agent knows this is not an alternative to a real publishing step.

Agents often have multiple tools that could apply. Explicit usage 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 flag a write (readOnlyHint=false, destructiveHint=true), and the description adds real context beyond them: the write cannot touch the brand profile, unmentioned axes 'keep what they had' (partial overwrite), and it 'requires the act scope'. It also states the return payload, which no output schema provides. Missing only edge cases like re-writing the same axis.

Agents need to know what a tool does to the 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 purpose, then routes with a WHEN clause, then closes with WHAT COMES BACK. No sentence is filler; even the 'Free; requires the act scope' fragment carries an actionable constraint.

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

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

For a single-nested-param write with no output schema, the description covers scope isolation, partial-update semantics, auth requirement, and return shape. An agent has everything needed to call it correctly and to know what it will and will not affect.

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

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

Schema coverage is 100% and the nested schema already defines 'lean' and 'strength' precisely, so the baseline is 3. The description still adds operational semantics not in the schema: omit axes with too few observations and send only axes that moved, which directly shapes what goes into the single 'axes' object.

Input schemas describe structure but not intent. Descriptions should explain 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 ('Write the calibrated leans ... into the FOUNDER'S OWN voice profile') and immediately carves out what it is not ('the personal register, never the brand's'). The two-voices distinction lets an agent separate it from brand-voice siblings 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?

Gives explicit timing ('after a round, once an axis has enough answers to read'), a batching rule ('one write per round, not one per pair'), and an exclusion rule ('leave out an axis with too few observations'). It stops short of naming sibling tools like get_voice_profile or record_voice_rule, but the when/when-not conditions are clear.

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

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

Annotations declare destructiveHint=true and openWorldHint=true, so the safety profile is partly covered. The description adds valuable context beyond the schema: it requires the 'act' scope, is free, and critically never publishes. It does not explain what mutation/destruction the destructiveHint implies (e.g., state transition effects), so it stops short of full 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?

Five dense sentences, each earning its place, with the critical precondition (founder confirmation) and the never-publishes correction front-loaded. 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 13-parameter mutation with no output schema, the description covers purpose, preconditions, routing, URL rules, scope, and cost. It omits what the move's resulting state becomes and how this relates to undo_move, but the sibling set covers reversal, 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 coverage is 85%, so the baseline is 3. The description adds conditional semantics not in the schema: completion_kind mapping (prepared_result after review vs independent_work for separate work) and the URL rule (live published_url to ship, planned_url stays prepared). That lifts it above baseline.

Input schemas describe structure but not intent. Descriptions should explain 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 ('Record completion') and immediately corrects the misleading name by clarifying 'This records an attestation; it never publishes anything.' This distinguishes it cleanly from siblings like review_move, accept_move, and skip_move.

Agents choose between tools based on descriptions. A clear purpose with a specific verb 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 conditions use on founder confirmation ('only after the founder explicitly confirms it') and routes between the two completion_kind values with named conditions. It also states the alternative condition for site changes (live published_url vs planned_url). Nothing is left to inference.

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

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

Annotations already declare destructiveHint=true and readOnlyHint=false, and the description adds genuinely new context: no cost, an authorization scope requirement, and the downstream effect that feedback improves future drafts. It stops short of saying whether the skip is reversible (undo_move exists) or what happens to the move record afterward.

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

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

A single dense sentence ordered by importance: action, cost, permission, then parameter purpose. No filler, nothing repeated from annotations.

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

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

For a one-required-parameter mutation with no output schema, the description covers cost, auth scope, and the feedback loop, so an agent has enough to call it correctly. The notable gap is reversibility/irreversibility of the skip, which matters for a destructiveHint 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 earns more by explaining that feedback_key is a closed vocabulary and that both feedback fields exist to improve future marketing drafts — meaning beyond the per-field schema text.

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

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

States a specific verb plus resource ('Dismiss a growth move') and anchors it to the user-facing action ('Skip in the Feed'), which cleanly separates it from siblings like accept_move, undo_move, and ship_move. An agent can pick it 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?

Provides a real prerequisite ('requires the act scope') and notes it is free, which helps gate invocation. However it never says when to use this versus accept_move/undo_move, nor that skipping is the negative counterpart to accepting — usage context 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?

With annotations only flagging safety hints, the description carries rich behavioral detail: the link is one-time, session-bound, lasts 15 minutes, must be handed to the founder, returns specific fields, and refuses before minting anything if the connector is shut. This is far more than the annotations convey.

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

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

Front-loaded with the action and the key constraint (you never complete consent), then return values, expiry, refusal behavior and cost in dense but non-redundant sentences. Every sentence adds operative 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?

No output schema exists, yet the description enumerates the returned fields and their meaning, the link lifetime, and the failure mode. An agent has everything needed to call it and act on 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?

The single provider parameter is fully documented in the schema (100% coverage), including allowed values, and the description adds nothing further about it. Baseline 3 applies when the schema does the heavy lifting.

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

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

States a specific verb and resource ('Connect a growth data source or distribution channel') and immediately describes the mechanism (mint a one-time link the founder approves). This clearly distinguishes it from siblings like poll_connection, disconnect_connection, and list_connections.

Agents choose between tools based on descriptions. A clear purpose with a specific verb 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 when-to-use context and a hard exclusion: 'You never complete the consent yourself; it is bound to their session,' plus the refusal case when a connector is shut. It implies the follow-up via poll_token/poll_after_seconds but never names poll_connection as the next step, so routing is left slightly 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?

Goes well beyond the destructiveHint=true annotation by spelling out the two concrete consequences (next scan runs at full depth, week-over-week trend is re-baselined) plus cost, 'config' scope, Founder-plan requirement, and free-trial readability. This is exactly the side-effect disclosure a mutation tool 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?

Purpose is front-loaded and every clause (cost, consequences, limits, permission requirements) carries information. It is dense and slightly long, but not padded.

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

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

For a one-parameter mutation with no output schema, it covers permissions, limits, and side effects thoroughly. It does not describe what is returned on success, which is a minor gap.

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

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

Schema coverage is 100% and already documents text's type and length bounds, so the baseline is 3. The description earns a point by adding constraints not in the schema: deduplication and the included-50 total limit.

Input schemas describe structure but not intent. Descriptions should explain 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 one customer question to the AI visibility (GEO) set'. This clearly distinguishes it from sibling untrack_prompt and list_tracked_prompts without needing to open 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?

Gives real usage context: it is free, and the agent is told to 'add deliberately rather than churning the list' because of the re-baselining consequence. It does not explicitly name untrack_prompt as the removal alternative, but the when-to-use condition is clear.

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

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

Annotations only declare readOnlyHint=false and destructiveHint=true; the description goes well beyond that by disclosing cost ('Free'), required scope ('act'), idempotency on an already-pending move, and the critical limitation that a posted output stays posted. These are exactly the behavioral facts an agent needs before invoking an undo-style mutation.

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

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

Two dense sentences, front-loaded with purpose followed by constraints, and every clause carries decision-relevant information (scope, cost, idempotency, restore limits). Nothing is padding.

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

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

For a one-parameter mutation with annotations present and no output schema, the description covers purpose, preconditions, side-effect boundaries, and failure cases. An agent has everything needed to decide whether to call it and what to expect.

Complex tools with many parameters or behaviors need more documentation. 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 move_id parameter is already documented as a uuid sourced from list_feed. The description adds no format, sourcing, or validation detail beyond the schema, so the baseline 3 applies.

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

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

States a specific verb (restore), resource (growth move), and the exact prior states it reverses (just-shipped or just-skipped), so an agent can tell it apart from ship_move, skip_move, and accept_move without opening a schema. The framing as 'the self-correction verb for a wrong ship or skip' pins the intent precisely.

Agents choose between tools based on descriptions. A clear purpose with a specific verb 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 when-to-use context (correcting a wrong ship or skip) and several when-not conditions: it never unwinds a real channel publish and cannot restore archived or expired moves. It does not name a sibling tool as the alternative (e.g., re-proposing via propose_move), so it stops just short of explicit 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?

Goes well beyond the annotations by disclosing that the call frees a slot against the 50-cap, costs nothing, triggers a full-depth next scan, and re-baselines the week-over-week trend. IDEMPOTENT and the case/punctuation-insensitive match are exactly the behavioral nuances the destructiveHint alone would not convey.

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

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

Front-loads the core action and effect, then stacks the operational facts (cap, cost, scan depth, re-baseline, matching, idempotency, permissions) efficiently. Slightly colour-heavy phrasing ('two honest consequences') costs it the top mark, but no sentence is wasted.

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

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

For a one-parameter mutation with no output schema, every fact an agent needs is present: side effects, cap accounting, permission and plan requirements, matching semantics, and idempotency. Nothing material is left to inference.

Complex tools with many parameters or behaviors need more documentation. 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 'text' parameter, so the schema already carries the match semantics and the pointer to list_tracked_prompts. The description restates the case/punctuation rule but adds no new 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 and resource ('Remove one customer question from the AI visibility (GEO) set') and implicitly contrasts with the add direction ('Same two honest consequences as adding one'), which maps to the sibling track_prompt. An agent can distinguish this from track_prompt and list_tracked_prompts 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?

Gives clear preconditions — 'Requires the config scope and the Founder plan' — and states the matching rule and idempotency, which tells the agent when a repeat call is safe. It does not explicitly name track_prompt as the inverse tool or state when not to call it, 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?

Beyond the annotations (destructiveHint=true, readOnlyHint=false), the description adds real behavioral context: invalid drafts with unfilled placeholders or broken links are refused rather than saved, and the call requires the 'act' scope and is free. It does not, however, explain what replacing does to the prior draft body or how conflicts surface.

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

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

Three short sentences, all front-loaded: the replacement action first, then the validation rule, then cost and scope. Every sentence carries distinct information with no redundancy.

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

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

With no output schema and a nested draft_fence object, the description covers the mutation, its validation gate, and its auth/cost profile, and the schema carries the fence semantics. It is nearly complete, though it could say more about what happens on success (e.g. move state transition).

Complex tools with many parameters or behaviors need more documentation. 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 move_id, draft_content, and the nested draft_fence are already documented in-schema, including the conflict-refresh note on draft_fence. The description adds no parameter-level detail beyond the schema, so the baseline 3 is appropriate.

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

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

The description states a specific verb and resource ('Replace a pending growth move's marketing draft body') and scopes it temporally ('before shipping'), which separates it from siblings like redraft_output or propose_move. An agent knows exactly what is being mutated and under what lifecycle condition.

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

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

Usage is implied by 'before shipping' and 'pending move', which tells the agent the move must be in a pre-ship state, but no alternative tool is named or excluded. There is no explicit guidance on when to choose this over redraft_output or review_move, leaving routing to inference.

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

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

Annotations already cover the safety profile (readOnlyHint, openWorldHint=false, destructiveHint=false), so the description earns credit for what it adds: feed_ready is false while the Growth Snapshot deep scan is still building, and credits only appear once metering is live. These state nuances explain why fields may be absent, which is genuinely useful beyond the annotations.

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

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

A single dense sentence front-loads the core action ('Confirm the AfterLaunch key works') before enumerating outputs. It is slightly run-on with the parenthetical and the trailing credits clause, but no sentence 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 burden of explaining return values, and it does list the key returned fields (scopes, tier, trial_ends_at, onboarding/feed_ready, credits) plus the condition under which some are populated. Reasonably complete for a zero-parameter diagnostic, though the field list is neither exhaustive nor typed.

Complex tools with many parameters or behaviors need more documentation. 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 baseline is 4. The description appropriately spends its words on the response shape instead, which is the right allocation for a parameterless tool.

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

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

States a specific verb ('Confirm') and a specific resource (the AfterLaunch key and its binding to a product run), then enumerates the fields returned: scopes, tier, trial_ends_at, onboarding and credits. An agent can tell this apart from get_enrollment or get_business_context, though it never explicitly names a sibling.

Agents choose between tools based on descriptions. A clear purpose with a specific verb 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: 'Confirm the AfterLaunch key works' suggests a diagnostic/bootstrap check, but there is no explicit when-to-use, when-not-to-use, or alternative tool named. An agent must infer the trigger condition.

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

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

Annotations already declare destructiveHint=true and readOnlyHint=false; the description adds value on top by stating the state transition (job withdrawn, move back to pending), that nothing is published, that the call is free, and that it requires the 'act' scope. It stops short of saying whether the withdrawn job is recoverable or what happens to the attempt record.

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

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

Three tightly packed sentences with the core effect front-loaded before preconditions and constraints. No filler, though the lead-in phrase is slightly ceremonious and the sentences are dense enough that the legacy path is easy to miss.

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

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

For an 8-parameter mutation tool with no output schema, the description covers the effect, the optimistic-concurrency preconditions, the legacy path, cost, and authorization scope. It does not explain what a caller should expect to observe after the call, but with destructive semantics already flagged by annotations 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 coverage is only 25%, so the description must compensate, and it does: it explains that job and attempt must be the exact current values, and which fields legacy work additionally requires (move and legacy states plus updated_at). Only the optional `note` parameter is left unaddressed.

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

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

States a specific verb and resource plus the concrete effect: withdrawing a job on an accepted move and returning the move to pending. This distinguishes it implicitly from skip_move/archive_move by outcome, but neither sibling is named, so the agent must reason about which cancellation-style sibling applies.

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

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

"Apply your user's explicit decision to cancel" gives a usage cue and the legacy-work sentence implies a second scenario, but there is no explicit when-not guidance and no comparison against the several adjacent siblings (skip_move, archive_move, undo_move, revise_move). Usage is implied rather than directed.

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