AfterLaunch: the agentic growth marketing engine

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

Annotations indicate non-destructive, and the description adds that archiving removes from Feed without recording a skip verdict, and it is idempotent. This discloses behavior beyond the annotations, such as idempotency and the effect on Feed. No contradiction.

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

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

The description is two sentences, tightly packed with essential information: purpose, comparison to skip, effect, idempotency, and scope requirement. No wasted words.

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

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

For a simple tool with one parameter and no output schema, the description covers purpose, behavior, prerequisites, and side effects. It omits return values and error handling, but these are often implicit for archive actions. Overall complete given the tool's complexity.

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

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

The only parameter (move_id) is well described in the schema (100% coverage). The description adds a hint that the id comes from list_feed, but does not significantly add meaning beyond the schema. Baseline 3 is appropriate.

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

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

The description clearly states the action (archive a growth move) and distinguishes it from the sibling tool 'skip_move' by noting it is a lighter dismissal that does not record a skip verdict. This provides specific verb+resource and differentiates from alternatives.

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

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

The description explains when to use this tool (as a lighter alternative to skip) and mentions it is free and requires the 'act' scope. Though it does not explicitly list when not to use it, the context from the sibling tool and the idempotency note guides appropriate usage.

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

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

The description complements the annotations (readOnlyHint: false, destructiveHint: false) by explaining that the tool creates a non-destructive, non-read-only action (creates a checkout link) and explicitly states constraints ('always bound to your own enrollment, so it can never upgrade a different account'). No contradictions.

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

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

The description is reasonably concise at three sentences, front-loading the core action and purpose. Minor improvement could be made by removing redundant phrasing, but it remains efficient and clear.

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

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

Given the tool has no parameters and no output schema, the description fully covers purpose, return value (checkout_url), side effects (auto-upgrade on payment), prerequisites (scope), and constraints (bound to own enrollment). No gaps remain.

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

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

The input schema has zero parameters, so schema coverage is 100%. The description confirms no parameters are needed, and its meaning is fully conveyed without requiring parameter documentation. Baseline for zero parameters 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?

The description clearly states the verb ('Create'), the resource ('Founder-tier checkout link'), and the specific context ('for THIS product run... the enrollment your key is bound to'). It distinguishes this tool from siblings (e.g., create_topup, archive_move) by its unique purpose of upgrading to Founder 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?

The description provides context on when to use this tool ('the way to unlock Founder-only growth controls', 'Reachable on a free trial') and the required scope ('Requires the 'act' scope'). However, it lacks explicit exclusion or comparison with similar tools, though none of the siblings appear to duplicate this functionality.

Agents often have multiple tools that could apply. Explicit usage 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 show readOnlyHint=false and destructiveHint=false, but the description adds valuable context: it generates a checkout URL, credits are added automatically on payment, and the top-up is bound to own enrollment (no cross-account crediting). This is more informative than annotations alone.

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

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

The description is a single paragraph of 4 sentences, front-loaded with purpose, then workflow and constraints. Every sentence adds essential information without redundancy.

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

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

Given the simple schema (1 param, no output schema) and basic annotations, the description fully covers purpose, usage, return value, payment flow, binding, and alternative for free trials. No gaps remain.

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

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

Schema coverage is 100% with 1 parameter (pack_id) and its description. The description adds context by stating the refill pack sizes (small, medium, large) and that the founder sees the price on checkout, enhancing the enum values' semantics.

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

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

The description clearly states the tool creates a credit top-up checkout link for the current product run, specifying the resource (credits) and distinguishing it from create_checkout (for free trial upgrades). The verb 'create' and resource 'top-up checkout link' are concrete.

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

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

The description explicitly says when to use the tool (refill credits when balance runs out), when not to (if on free trial, use create_checkout first), and lists prerequisites (requires 'act' scope and Founder plan). This provides clear guidance on alternatives.

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

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

Annotations already declare readOnlyHint=true and destructiveHint=false. The description adds behavioral context: results are newest-first, read-only, free, and details what entries are included (drafts, ships, etc.). No contradiction.

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

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

Three concise sentences, each serving a clear purpose: stating what the tool returns, why to use it, and ordering. No superfluous information.

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

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

Given the low complexity (1 non-required parameter, no output schema, no nested objects), the description fully covers purpose, usage, and behavioral traits. It is complete for an agent to select and invoke correctly.

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

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

Schema coverage is 100% with a clear description for the single parameter 'limit' (1-200, default 50). The description does not add parameter-specific details beyond the schema, so baseline score of 3 is appropriate.

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

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

The description clearly states the tool returns the product timeline of growth agent and founder actions (drafts, ships, skips, etc.) with rationale, using the verb 'get' and resource 'activity'. It distinguishes from siblings by specifying the unique content type.

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

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

Explicitly advises to read before acting to avoid redoing or contradicting recent work, providing clear when-to-use context. Does not explicitly state when not to use, but the positive guidance is strong.

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

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

Annotations already provide readOnlyHint=true and destructiveHint=false. The description reinforces 'Read-only, free' and adds valuable behavioral context (founder's own edits, warning about pitch targets). No contradictions.

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

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

Description is efficiently structured with front-loaded purpose and detail, then usage guidance. Every sentence adds value, though it could be slightly more concise.

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

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

Given no parameters, no output schema, and existing annotations, the description fully explains the tool's purpose, data returned, and usage context. It is complete and 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?

There are zero parameters, so schema coverage is 100% and description does not need to add parameter details. Baseline is 4 as per guidelines.

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

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

The description clearly states it retrieves a competitor roster with a comprehensive list of metrics (performance, SEO, accessibility, Core Web Vitals, domain age/authority, G2, Product Hunt, content freshness). It also mentions it includes founder's edits, distinguishing this tool from siblings like get_activity or get_outcomes which have different domains.

Agents choose between tools based on descriptions. A clear purpose with a specific verb 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 advises reading this before any competitor or outreach work to avoid treating a rival as a pitch target. This gives clear when-to-use context. While it doesn't explicitly list when not to use or alternative tools, the guidance is strong and specific.

Agents often have multiple tools that could apply. Explicit usage 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 note readOnlyHint=true and destructiveHint=false. The description adds value by detailing the returned fields and their conditional presence (e.g., credits only when metering is live), extending beyond what 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?

Single, dense sentence that front-loads the purpose. All content earned its place—no filler, efficient listing of fields with conditional note. Highly concise yet informative.

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

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

Despite lacking an output schema, the description comprehensively enumerates the response fields and their conditions (e.g., credits field behavior). No gaps for a read-only summary 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?

Input schema has no parameters (0 params, 100% coverage), so description need not explain parameters. Baseline 4 applies as description adds no param info, which is acceptable given zero parameters.

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

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

Description clearly identifies the tool's output as 'The product run summary for this AfterLaunch growth engine', listing specific fields like product_url, tier, trial_ends_at, etc. It distinguishes itself from sibling tools (e.g., archive_move, create_checkout) by focusing on retrieval of enrollment details.

Agents choose between tools based on descriptions. A clear purpose with a specific verb 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 use to retrieve a summary for a specific enrollment, but lacks explicit guidance on when to choose this tool over siblings. No alternatives or when-not-to-use conditions are provided.

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

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

Annotations already declare readOnlyHint=true and destructiveHint=false. The description reinforces this with 'Read-only, free' and adds context about it being shared memory, but does not significantly expand on behavior beyond annotations.

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

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

The description is concise, using two sentences to convey purpose, source of parameter, and key attributes. It is front-loaded and efficient.

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

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

For a simple one-parameter read-only tool with annotations, the description fully covers what the tool does, where input comes from, and what output to expect (full markdown body). No output schema needed.

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

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

Schema coverage is 100% with the slug parameter already described. The description merely repeats that the slug comes from list_kb_pages, adding no new semantic information beyond what the schema provides.

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

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

The description clearly states the tool retrieves a single Knowledge Base page by slug, including its full markdown body. It differentiates from list_kb_pages which provides slugs without content.

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

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

The description explains the tool's role as shared memory for drafting and specifies that slugs come from list_kb_pages. It also notes the tool is read-only and free, but does not explicitly state when not to use it or list alternative tools.

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

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

Annotations already indicate read-only, non-destructive behavior. Description adds substantial context: returns autonomy level and runnable_loop_types, clarifies that provisioned loops may not be runnable. No contradictions with annotations.

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

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

Description is moderately concise, using one paragraph with clear structure: first sentence states main purpose, then explains distinction, then usage. Every sentence adds information, but could be slightly more streamlined.

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

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

Given the tool's relative simplicity (1 optional parameter, no output schema), the description covers the key aspects: what is returned, the relationship between provisioned and runnable, and parameter usage. It is sufficiently complete for an agent to correctly select and invoke the tool.

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

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

Schema coverage is 100% (parameter documented in schema). Description adds value by stating the effect of passing vs omitting the parameter, which is beyond the schema's simple example list.

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

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

Description clearly states the tool retrieves provisioned growth marketing loops and runnable loop types, distinguishing between the two. It is specific about the resource (agent_loops rows) and scope (per product). However, it does not explicitly differentiate from sibling tools like run_loop, set_loop_autonomy, though the action is distinct.

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

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

Provides clear usage guidance: pass loop_type for a single loop, omit for all. Explains the difference between provisioned and runnable loops, which helps agents decide when to use this tool. Does not explicitly state when not to use or mention alternatives, but the context is sufficient.

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

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

Annotations already declare readOnlyHint=true, so description adds value by listing the data returned and stating it's 'free'. Does not contradict annotations. However, no additional behavioral details (e.g., idempotency) beyond what annotations 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?

Two sentences front-load key info, but the first sentence is somewhat verbose with marketing phrasing ('proof read'). Could be more concise while retaining meaning.

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

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

With no output schema, the description provides a list of returned metrics, which is helpful but lacks structure (e.g., format, data types). Adequate for a zero-parameter tool but incomplete for fully understanding output.

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

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

No parameters exist, so schema coverage is trivially 100%. Description does not need to add parameter info, but it provides context about the data returned instead.

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

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

The description clearly states that the tool retrieves outcomes of shipped growth moves, including specific metrics like tracked-link clicks and scoreboard. It distinguishes itself from sibling tools by emphasizing its use after ship_move, though it could be more explicit about its uniqueness.

Agents choose between tools based on descriptions. A clear purpose with a specific verb 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 advises calling 'after ship_move', providing clear context for when to use. No mention of when not to use or alternatives, but the guidance is specific and helpful.

Agents often have multiple tools that could apply. Explicit usage 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. The description adds that the tool returns 'full content body,' which is additional behavioral context about the output. No contradictions.

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

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

Two sentences with no wasted words. First sentence states action and scope; second gives practical guidance and safety qualifier. Perfectly front-loaded.

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

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

For a simple tool with one parameter, clear annotations, and no output schema, the description covers purpose, source of ids, and safety. Nothing essential is missing.

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

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

Schema coverage is 100% (output_id described as uuid). The description's tip to get ids from list_outputs adds contextual value beyond the schema, but does not elaborate on parameter details.

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

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

The description clearly states the tool retrieves a single drafted marketing output by id, including full content body. It specifies the resource type ('a channel or distribution draft') and distinguishes from sibling list_outputs.

Agents choose between tools based on descriptions. A clear purpose with a specific verb 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 advises to get ids from list_outputs first, providing a clear precondition. The 'Read-only' label indicates safe usage, but no direct mention of when not to use or alternatives for modifications.

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

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

Annotations already indicate read-only and non-destructive; description adds 'free' and that seo_fix moves are based on the audit, providing useful context without contradicting 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?

Four sentences, front-loaded with output components, efficient and scannable. 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 lacking output schema, the description enumerates all major output sections (issue groups, score trend, page performance, etc.), making the tool's results fully predictable.

Complex tools with many parameters or behaviors need more documentation. 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 already documents the include_pages parameter with description; tool description adds minor emphasis ('Pass include_pages') but does not significantly enhance understanding beyond schema.

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

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

The description clearly states the tool provides a site-wide SEO audit listing specific components (issue groups, score trend, page performance, etc.) and distinguishes it from sibling tools like get_visibility and get_competitors by noting its role as the primary SEO audit.

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

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

Advises reading the audit before doing SEO work and links to seo_fix moves, providing clear context for when to use. Lacks explicit exclusion or comparison to alternatives but the context is strong.

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

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

Annotations already declare readOnlyHint=true and destructiveHint=false. Description adds that it is free, no arguments, and instructs agents to write the snippet into the repo, providing useful behavioral guidance 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?

Description is 4-5 sentences, front-loaded with purpose. Some redundancy in listing capabilities, but overall efficient and informative.

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

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

For a read-only tool with no parameters and no output schema, the description fully explains the content, purpose, and intended action. No gaps remain.

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

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

No parameters exist, so schema coverage is 100% trivially. The description adds no parameter information, which is appropriate. Baseline score of 4 for zero parameters.

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

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

Clearly states it returns a paste-able markdown section for CLAUDE.md or AGENTS.md, specifying it's free, read-only, and has no arguments. Distinguishes from sibling tools which perform various operations like archiving or updating.

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

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

Provides explicit context: 'Write it into the repo rather than asking the founder to copy it.' Implicitly suggests when to use (during setup) and what the tool does not do (cost, etc.), but lacks explicit when-not-to-use or alternatives.

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

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

The description reinforces the annotations (readOnlyHint, destructiveHint) by stating 'Read-only, free.' It also adds detail about the snapshot contents beyond what annotations provide.

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

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

The description is somewhat verbose and run-on, mixing content details with usage guidance. It could be more concise and better structured.

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

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

Given no output schema and the tool's complexity (returns a multi-faceted snapshot), the description covers the main data elements and provides alternatives. It is reasonably complete.

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

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

There are no parameters, so the description's job is to explain what the tool returns, which it does by listing the snapshot components. This adds value beyond the empty schema.

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

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

The description lists the data returned (positioning, discoverability score, etc.) but lacks a concise verb+resource statement of what the tool does. It is somewhat vague and can be confused with other snapshot tools like get_activity 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?

The description explicitly directs users to use get_visibility and get_seo for live signal data, providing a clear alternative. However, it does not address when to use this tool over other snapshot siblings like get_activity.

Agents often have multiple tools that could apply. Explicit usage 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. Description adds behavioral details: 'Read-only, free', ordering relative to refresh_scan, and the effect of passing prompt_id for drill-down.

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

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

Description is moderately long but every sentence adds value, front-loading the main purpose. Could be slightly more concise but well-structured.

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

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

Despite no output schema, the description thoroughly enumerates return data (share of voice, per-engine coverage, cited sources, trends, off-site signals) and explains the optional parameter's effect, providing complete guidance for a read-only 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 has 100% coverage for the single optional parameter. Description adds precise meaning: 'Pass prompt_id to drill into one question with full engine answer text where your plan includes it', enriching the schema description.

Input schemas describe structure but not intent. Descriptions should explain 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 specifies retrieving 'AI visibility (GEO) results' with detailed data points (share of voice, per-engine coverage, cited sources, etc.) and distinguishes from sibling tools by contextualizing its role in the analysis workflow.

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

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

Explicitly states to read after 'refresh_scan' and before AI visibility work, and notes it is read-only and free. Lacks explicit when-not-to-use or alternatives, but provides clear sequencing.

Agents often have multiple tools that could apply. Explicit usage 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. Description adds default behavior (live moves only), the effect of include_resolved, and the total_live count, which enhances transparency beyond annotations.

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

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

The description is a single paragraph but efficiently covers purpose, fields, usage instruction, and parameter behavior with no wasted words. Slightly lacks structural breaks but remains effective.

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

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

For a simple list tool with one optional parameter and no output schema, the description comprehensively lists returned fields (title, why it matters, area, status, rank, draft_content) and explains default filtering and total_live count, making it 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?

Schema covers the single parameter with description. The description reiterates the parameter's effect and adds context about default behavior and the returned total_live count, adding value beyond the schema.

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

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

The description specifies the tool returns a ranked backlog of growth marketing moves with details (title, why it matters, area, status, rank, draft_content). It clearly distinguishes from sibling tools by advising to read this before any growth work.

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

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

Explicitly states 'Read this before improvising any growth, marketing, SEO or launch work of your own,' providing clear guidance on when to use. However, no explicit alternatives or when-not-to-use instructions 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 declare readOnlyHint=true and destructiveHint=false, so the behavioral safety is clear. The description adds that it returns summaries with a size hint and is read-only and free, providing modest additional context beyond the annotations.

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

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

The description is only two sentences, but the first sentence is a noun phrase that explains the Knowledge Base concept rather than directly describing the tool's action. The second sentence contains the core information. Could be more concise and front-loaded with an imperative verb.

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

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

The description explains that it returns summaries with a size hint and directs to get_kb_page for full body, but does not specify what the summaries contain (e.g., title, excerpt), whether all pages are listed, or if there is pagination. Given no output schema, more detail on return format would improve completeness.

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

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

The input schema has zero parameters, so description does not need to explain parameters. Per criteria, 0 parameters yields a baseline of 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?

The description states it returns summaries of Knowledge Base pages and contrasts with get_kb_page for fetching full page bodies. However, the primary verb is implied rather than explicit, as the description starts with a noun phrase instead of an imperative verb like 'List'.

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

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

The description does not provide explicit guidance on when to use this tool versus alternatives, nor does it mention any prerequisites or exclusions. It only hints at using get_kb_page for full bodies, but lacks clear when-to-use or when-not-to-use instructions.

Agents often have multiple tools that could apply. Explicit usage 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. The description adds that the tool is 'Read-only' and outputs newest first, which provides some context beyond annotations but does not disclose additional behavioral traits.

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

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

Two sentences: first lists fields and ordering, second gives usage guidance. No wasted words, front-loaded with purpose. Excellent conciseness.

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

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

Given no parameters and no output schema, the description covers purpose, returned fields, ordering, and usage with siblings. Lacks details like pagination limits or filtering, but adequate for a simple list tool.

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

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

With zero parameters and 100% schema coverage, the description adds no parameter-level information. Baseline score of 3 is appropriate per guidelines.

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

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

The description clearly states it lists 'drafted marketing and distribution content' for a product, specifying fields returned (id, loop_type, kind, status, title) and ordering (newest first). It implicitly distinguishes from 'get_output' and 'approve_output' but does not contrast with other list tools like 'list_feed' or 'list_kb_pages'.

Agents choose between tools based on descriptions. A clear purpose with a specific verb 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 advises to use IDs with 'get_output' for full content or 'approve_output' to dispatch, providing clear guidance on when to use this tool versus siblings. It does not list all 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?

Beyond annotations (readOnlyHint=false, destructiveHint=false), the description adds key behavioral traits: it's a write operation that replaces the body, but the previous draft is kept as revision history, confirming non-destructive behavior. Also flags scope/tier 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?

Three short sentences efficiently convey the tool's purpose, prerequisites, limitations, and side effects. No redundant information; every sentence earns its place.

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

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

For a write tool with no output schema, the description adequately explains outcomes (replaced body, previous draft kept), prerequisites (scope, tier), and usage context (manual vs AI). It also hints at integration with other tools (get_output, list_outputs, ship_move). Complete enough for an agent to use correctly.

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

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

Schema coverage is 100% with parameter descriptions. The tool description doesn't add new semantic details beyond those in the schema, but it mentions that output_id comes from list_outputs, which is helpful context. Baseline of 3 is appropriate given complete schema coverage.

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

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

The description clearly states the action ('Replace a drafted marketing output's body'), the resource ('drafted marketing output'), and the context ('before it is shipped'). It also distinguishes between manual replacement and instruction-driven AI redraft, making the purpose specific and unambiguous.

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

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

The description provides explicit usage guidance: requires 'act' scope and Founder tier, manual-only (AI redraft stays in app), and previous draft is kept as revision. It doesn't directly compare with sibling tools like update_draft, but the manual vs AI distinction gives clear context for when to use this tool.

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

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

The description goes far beyond annotations by declaring 'SPENDS MONEY', explaining idempotency, daily limits, credit balance, and spend caps. Annotations only indicate non-readonly and non-destructive; the description adds critical behavioral context. No contradiction.

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

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

The description is a single paragraph that packs essential information without fluff. Every sentence adds value, but it could be more structured (e.g., bullet points) for easier parsing. Still, it is appropriately sized for the complexity.

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

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

The description lacks information about the return value or output. Given no output schema, the agent needs to know what the tool returns (e.g., scan results, status). It covers prerequisites and behavior well, but this gap reduces completeness.

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

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

Schema coverage is 100%, but the description adds meaning: for 'idempotency_key', it explains it must be client-minted for contract stability and repeats replay results. For 'scan', it confirms only 'ai_visibility' today. This adds value beyond the schema descriptions.

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

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

The description clearly states the tool runs an on-demand AI visibility scan, specifies the scan type 'ai_visibility', and explains what it measures (GEO representation). This distinguishes it from sibling tools like get_visibility or run_loop, which have different purposes.

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

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

The description explicitly states when to use: requires 'write' scope, paid plan or active trial, and an idempotency key. It also describes limitations like daily per product cap and repeat behavior. However, it does not mention alternatives or when not to use.

Agents often have multiple tools that could apply. Explicit usage 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 (readOnlyHint=false, destructiveHint=false) are supplemented with extensive behavioral details: spending money, needing write scope, requiring idempotency key, credit limits, and daily/monthly caps. No contradictions.

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

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

Description is dense but front-loads the critical warning about spending money. Every sentence adds value, though it could be slightly more concise by grouping requirements. Overall well-structured.

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

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

Low complexity (1 parameter, no output schema). Description covers purpose, usage conditions, limitations, and prerequisites. No gaps given the context.

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

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

Only one parameter (idempotency_key) with 100% schema coverage, so baseline is 3. The description adds no new semantic detail beyond the schema's description of key length and idempotency behavior.

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

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

The description clearly states the tool's purpose: 'run the growth-move generator on demand to top up the Feed with fresh marketing moves' and lists specific areas (SEO, AI visibility, competitors, distribution channels). It distinguishes from siblings like list_feed or ship_move by focusing on generating new moves.

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

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

Explicitly states when to use: requires write scope, paid plan/trial, idempotency key. Also specifies limitations: bounded by credit balance, limited to once per day per product, subject to per-tenant caps. This provides clear guidance on when and when not to use.

Agents often have multiple tools that could apply. Explicit usage 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 (readOnlyHint=false, destructiveHint=false) by disclosing that it spends money (costs 1 credit), requires 'write' scope, has idempotency behavior (repeat runs replay result at no cost), and is subject to spend caps. These are critical behavioral traits that annotations alone do 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?

The description is relatively long but every sentence adds necessary information. It is front-loaded with 'SPENDS MONEY' in caps. Minor inefficiency could be trimmed, but overall it is well-structured and informative.

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

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

The description covers purpose, usage constraints, and behavioral details well. However, it lacks information about the return value or output structure, which would be helpful since there is no output schema. This is a moderate gap for a tool that triggers an asynchronous run.

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

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

Schema coverage is 100% with good descriptions for both parameters. The description adds extra context: examples for loop_type and the idempotency behavior (one per loop per product per cycle) that goes beyond the schema descriptions.

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

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

The description clearly states the tool triggers one on-demand generation run of a growth marketing loop, provides specific examples (linkedin_post, geo_improvement, competitor_intel), and includes key details like cost and idempotency. This distinguishes it from sibling tools like get_loop_status or set_loop_autonomy.

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

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

The description explains when to use the tool (to trigger a run) and includes constraints (one per loop per product per cycle, subject to caps, requires runnable type and provisioning). It does not explicitly name alternatives but the context is clear enough for an agent to decide.

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

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

Annotations indicate non-readonly and non-destructive. Description adds context that certain loop types reject autonomous mode, but doesn't detail other behavioral aspects like reversibility or effect on running loops.

Agents need to know what a tool does to the 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: first states purpose with options, second gives requirements and constraints. No wasted words.

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

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

Covers required parameters, scope/tier, and special constraints. No output schema needed. Minor gap: does not explain what happens if an invalid combination is attempted.

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

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

Schema covers level enum but no description; loop_type has schema description. Description lists the three levels but does not explain their behaviors, partially compensating for 50% schema coverage.

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

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

Description clearly states the tool sets the autonomy level of a growth marketing loop, listing the three possible values. This distinguishes it from sibling tools like set_loop_cadence.

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

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

Explicitly states required scope and tier, and specifies that social/distribution channels cannot use 'autonomous', providing clear when-to and when-not guidance.

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

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

The description discloses mutability (readOnlyHint=false) and non-destructiveness (destructiveHint=false), but adds important behavioral details: the direction constraint (can only slow/pause), the concept of an override, and prerequisite scope/tier. This goes well beyond the minimal annotation information.

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

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

The description is three sentences, front-loaded with the purpose. Every sentence adds value: purpose, requirements, constraint, and side effect. No redundant or vague wording.

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

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

Considering no output schema, the description covers constraints, allowed values, prerequisites, and behavior. It could mention whether a confirmation or status is returned, but the provided information is sufficient for an agent to use the tool correctly.

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

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

Schema coverage is 50% (only loop_type has a schema description). The description adds semantic value by explaining the meaning of each cadence enum value (e.g., 'default' means normal cadence, 'paused' halts it) and the implication of clearing overrides. However, loop_type is not further elaborated beyond what's in the schema.

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

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

The description clearly states the tool sets the cadence of a growth marketing loop, listing the four valid values and providing context. It distinguishes from siblings like set_loop_autonomy by focusing on timing rather than autonomy.

Agents choose between tools based on descriptions. A clear purpose with a specific verb 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 specifies required scope and tier (Founder, 'config' scope) and a key constraint (only slow or pause, never speed up). It also explains the effect of setting 'default'. While it doesn't explicitly mention alternative tools, the guidance is clear and actionable.

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

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

Annotations only indicate non-read-only and non-destructive. The description adds idempotency, non-publishing behavior, authorization requirements (act scope, Founder tier), and the effect of each action beyond schema definitions.

Agents need to know what a tool does to the 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 informative and well-structured, front-loading the primary purpose. It could be slightly more concise, but all sentences add value.

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

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

Given no output schema and simple parameters, the description covers purpose, behavior, idempotency, prerequisites, and alternative tools. No gaps remain for a tool of this complexity.

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

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

Schema covers both parameters with descriptions. The description adds contextual information: output_id source, action effects (e.g., 'ship' sets done or posted-status) and reaffirms that it never publishes, providing meaning beyond enum labels.

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

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

The description clearly states the tool resolves drafted marketing outputs with actions 'ship' or 'skip', differentiates from approve_output, and references the source tools list_outputs/get_output. It specifies the resource and action 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?

The description explicitly contrasts this tool with approve_output, indicating when to use each. It mentions the context (founder's review queue) but does not explicitly state when not to use it beyond the publishing distinction.

Agents often have multiple tools that could apply. Explicit usage 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 show it's not read-only (modifies state) and not destructive. Description adds that it's free and action-equivalent to the Ship button. No details on idempotency or side effects, but adequate for a simple state update.

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

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

Two sentences, no fluff, front-loaded with action and key details. Every word earns its place.

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

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

No output schema, but mutation tools often don't need one. Description covers purpose, scope requirement, and parameter usage. Given the sibling set, it's sufficient for distinguishing and using 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 already describes both parameters (100% coverage). Description adds value by clarifying when to use asset_url ('only when the move published a live content asset'), which is actionable beyond the schema definition.

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

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

The description clearly states it marks a growth move shipped, akin to the founder's Ship button. It distinguishes from siblings like undo_move and skip_move by focusing on the shipped state.

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

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

Explicitly mentions requiring the 'act' scope and provides guidance to pass asset_url only when a live asset is published. No explicit when-not-to-use, but condition on asset_url is helpful.

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

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

Annotations indicate it is not read-only or destructive. The description adds that the tool is free, requires the 'act' scope, and that providing feedback improves future marketing drafts. This goes beyond annotations.

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

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

Two sentences, front-loaded with the main action, no wasted words. Every sentence adds distinct value: action, scope, parameters, and effect.

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

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

For a simple dismiss action, the description covers the essential usage, parameters, and side effect (improving drafts). It does not describe the response, but given no output schema, this is acceptable. It is mostly complete.

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

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

Schema coverage is 100%, so baseline is 3. The description adds meaning: it explains feedback_key is a closed vocabulary (referencing the enum) and that unknown keys are ignored by the learning loop, and feedback_note is free-text to explain why. This adds behavioral context beyond the schema.

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

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

The description clearly states it dismisses a growth move, explicitly equating it to 'Skip in the Feed' to differentiate from sibling actions like archive or ship. It uses a specific verb and resource.

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

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

The description implies usage for dismissing moves (like Skip in the Feed) and notes it is free and requires the 'act' scope. It provides clear context but does not explicitly state when not to use it or name alternatives.

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

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

The description adds significant behavioral context beyond annotations: it is idempotent on already pending moves, it is free, and it never reverts channel publishes. These details help the agent understand side effects and limitations, compensating for the lack of destructiveHint (which is false, correctly indicated) and readOnlyHint (false, as it writes).

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

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

The description is a tight, front-loaded paragraph. The first sentence captures the core action and scope, followed by short clarifying statements. Every sentence adds value without redundancy.

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

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

Given the tool's low complexity (1 param, no output schema), the description fully covers all essential aspects: action, scope, preconditions (shipped/skipped moves), idempotence, limitations, and exclusion of irreversible effects. No gaps remain.

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

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

With 100% schema description coverage for the single parameter (move_id described as 'The growth move id (uuid), from list_feed'), the description adds no further parameter-level details. The baseline of 3 is appropriate because the schema already provides sufficient meaning.

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

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

The description clearly states the verb 'restore' and resource 'growth move', and explicitly contrasts it with ship_move and skip_move by calling it the 'self-correction verb' for those actions. It also ties the action to the founder's Undo in the Feed, making the purpose unambiguous and distinct from siblings.

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

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

The description explicitly states when to use ('restore a just-shipped or just-skipped growth move to pending'), when not to use ('never unwinds a real channel publish', cannot restore archived/expired moves), and includes the required scope ('requires the 'act' scope'). This provides clear boundaries and decision support.

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

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

Annotations already declare readOnlyHint=false and destructiveHint=false. The description adds context about cost ('Free') and required scope ('act'), which goes beyond annotations. It doesn't detail failure modes or side effects, but the behavioral profile is fairly clear.

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

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

The description is a single sentence plus a fragment for cost/scope, with no wasted words. The action is front-loaded, making it easy to parse.

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

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

Given the simplicity (2 simple params, no output schema), the description adequately covers purpose, scope, and cost. It lacks detail on error conditions or what happens if the move isn't pending, but overall sufficient for an agent.

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

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

The schema covers both parameters with descriptions (100% coverage), so the description adds no extra parameter-level meaning. Baseline 3 is appropriate as the schema suffices.

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

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

The description clearly states the specific action ('Replace') and resource ('pending growth move's marketing draft body'), and distinguishes from siblings like 'ship_move' and 'redraft_output' by specifying the context 'before shipping'.

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

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

The description implies when to use this tool ('before shipping') and provides cost ('Free') and auth scope ('requires the 'act' scope'). However, it does not explicitly state when not to use it or provide alternatives among the many sibling tools.

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

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

Description adds significant value beyond annotations by detailing returned fields (enrollment, key, scopes, product identity) and noting conditional credit field presence when metering is active.

Agents need to know what a tool does to the 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 effectively convey purpose and details. First sentence is dense but well-structured; second sentence clarifies a conditional. No extraneous content.

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

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

Given zero parameters and explicit annotations, description fully covers the tool's behavior, including return fields and conditional credit data. No output schema needed.

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

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

No parameters, so description does not need to add parameter info. Baseline 4 applies; description remains clear on what is returned.

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

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

Description clearly states the tool confirms API key validity and returns specific enrollment, key, and product identity data. The verb 'Confirm' and resource description make purpose unambiguous.

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

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

Explicitly says 'Call this first', providing a clear use case. While no exclusion or alternative is stated, the directive is strong enough for context.

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