AfterLaunch: the agentic growth marketing engine

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

Beyond the readOnlyHint and destructiveHint annotations, the description discloses useful behavioral traits: it is 'Free' (cost/rate implication), requires the 'act' scope (authorization context), and is 'Idempotent on an already-archived move.' It also clarifies a key side effect: 'no verdict recorded.' These details add significant value and do not contradict 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 two sentences, front-loaded with the primary action and then delivering key differentiators and constraints. Every phrase earns its place; no filler or redundancy.

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

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

For a simple one-parameter mutation tool with annotations and full schema coverage, the description provides purpose, usage contrast, authorization, idempotence, and cost context. It does not mention the return value or success/failure behavior, but with no output schema defined, this is a minor gap; the description is sufficiently complete for an agent to select and invoke the tool correctly.

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

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

The input schema already fully describes the only parameter (move_id: 'string, from list_feed') with 100% coverage. The description adds no additional parameter-specific meaning beyond the schema, so the baseline of 3 applies.

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

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

The description clearly states the action ('Archive a growth move') with a specific verb and resource, and explicitly distinguishes it from skip by noting it's 'a lighter dismissal than skip, with no verdict recorded.' This differentiates it from the sibling skip_move and other move-related tools.

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

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

It provides a clear context for when to use this tool versus skip_move by contrasting them ('lighter dismissal than skip, with no verdict recorded'), implying the use case. However, it does not explicitly list other alternatives or state when NOT to use it beyond the skip comparison, so it stops short of full when/when-not guidance.

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

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

Annotations only provide readOnlyHint=false and destructiveHint=false, so the description carries the burden. It transparently discloses the return of a checkout_url, automatic upgrade on payment, and binding to the caller's enrollment.

Agents need to know what a tool does to the 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 with no fluff. It front-loads the core action and then efficiently covers prerequisites and outcome.

Shorter descriptions cost fewer tokens and are easier for agents to parse. 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 tool with no output schema, the description is nearly complete: purpose, usage context, requirements, and result are all covered. It could mention error cases or already-Founder states, but those are edge cases.

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

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

The tool has zero parameters and the input schema is empty with 100% coverage, so the baseline is 4. The description adds no parameter details, but they are not needed.

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

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

The description clearly states 'Create a Founder-tier checkout link for THIS product run' and explains its purpose as unlocking Founder-only growth controls, distinguishing it from siblings like create_topup. The verb and resource are specific.

Agents choose between tools based on descriptions. A clear purpose with a specific verb 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 mentions it is 'Reachable on a free trial because it is the path TO Founder', providing clear context on when to use it. It also notes the required 'act' scope and own-enrollment binding, though it does not explicitly 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?

Beyond annotations (readOnly=false, destructive=false), the description discloses return value ('Returns a checkout_url'), automatic side effect ('credits land automatically once payment succeeds'), auth requirements ('Requires the 'act' scope'), and a critical context constraint ('Always bound to your own enrollment'). This substantially enriches behavioral understanding.

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

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

The description is compact and front-loaded with the primary action. Every sentence contributes: purpose, parameter instruction, return behavior, prerequisite/alternative, and binding constraint. No filler or redundancy.

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

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

For a one-parameter tool with no output schema and minimal annotations, the description covers prerequisites, side effects, return value, alternative usage, and contextual binding. It is fully sufficient 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?

The schema already provides 100% coverage for pack_id with an enum and description. The description repeats 'Pass pack_id: small, medium or large' but adds no new meaning about parameter semantics. Per the rubric, baseline 3 is appropriate when schema covers the parameter fully and the description merely echoes 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?

The description clearly states the action: 'Create a credit top-up checkout link for THIS product run,' specifying the resource (credits for metered growth marketing) and distinguishes this tool from create_checkout by framing it as a top-up rather than an initial checkout.

Agents choose between tools based on descriptions. A clear purpose with a specific verb 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-to-use and when-not-to-use guidance is given: 'Requires the 'act' scope and the Founder plan (on a free trial use create_checkout first).' This names the alternative tool and clarifies eligibility, making the usage context unambiguous.

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

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

Annotations say destructiveHint=false, but the description explicitly says it 'delete[s] the credential' and 'for Google it is also revoked at Google,' indicating irreversible destructive behavior. This is a direct contradiction, so the score is 1.

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

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

Three sentences, front-loaded with the primary action, and every sentence adds value—including idempotency and the need for founder confirmation. 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?

The description covers purpose, idempotency, and consequences, which is fairly complete for a one-parameter tool, but the contradiction with the destructiveHint annotation makes the overall information misleading and incomplete regarding safety.

Complex tools with many parameters or behaviors need more documentation. 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 the single parameter with a description of allowed values, and the tool description adds nothing about the parameter beyond that. With 100% schema coverage, a baseline of 3 is appropriate.

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

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

The description clearly states the action ('Disconnect a growth data source or distribution channel') and the additional detail of credential deletion, distinguishing it from sibling tools like start_connection or 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?

It provides implicit guidance by noting the impact ('narrows what the growth engine can measure') and instructing to 'confirm with the founder first,' but does not explicitly contrast with 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?

Despite sparse annotations (readOnlyHint=false, destructiveHint=false), the description goes well beyond them. It discloses that the action resolves the gap in one place, stops re-proposal on the Feed, improves ranking with the reason, and is idempotent (leaves shipped/archived gaps untouched). This gives the agent a rich behavioral model without relying on 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 somewhat long but every sentence contributes specific information: purpose, comparison to skip_move, feed/ranking effects, pricing/scope, and idempotency. It is front-loaded with the core purpose and structured logically, though could be slightly tightened without losing meaning.

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

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

For a mutation tool with no output schema and minimal annotations, the description is quite complete: it explains the action, effects, idempotency, and prerequisites. It doesn't describe the return value, but since no output schema exists, this is less critical. It also doesn't explicitly discuss reversibility (undo_move exists as sibling), which is a minor gap given the tool's impact.

Complex tools with many parameters or behaviors need more documentation. 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 all parameters with 100% coverage, so the description doesn't need to repeat basic meanings. However, it adds value by explaining that the reason 'improves what gets ranked next' and reinforces that prompt_id and prompt_text together identify the gap, which goes beyond the schema's existing 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 defines the action: 'Set aside one AI visibility (GEO) gap' with a specific resource ('a tracked question where rivals get named and this product does not'). It explicitly distinguishes from sibling skip_move by saying 'The same verdict as skip_move, on the AI visibility surface', making the tool's unique scope unmistakable.

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

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

It provides a clear condition for use ('the founder is not going to act on') and contrasts with skip_move by specifying this is for the AI visibility surface. It also states effects (stops re-proposed on feed, improves ranking) and requirements (free, requires 'act' scope, all plans). However, it doesn't explicitly discuss alternatives like archive_move or undo_move, leaving some ambiguity about when not to use this over those.

Agents often have multiple tools that could apply. Explicit usage 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 read-only and non-destructive, so the description adds contextual value: the timeline is newest-first, includes rationale, and is 'free' (no cost). This goes beyond the safety annotations and clarifies the content 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?

The description is three brief sentences covering purpose, usage, and a safety/cost note. The purpose sentence is dense but well-structured, and every sentence earns its place with no redundancy.

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

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

For a simple read-only list tool with one optional parameter, the description adequately covers what it returns (activity timeline with rationale), the ordering (newest first), and the practical use case (prevent redoing recent work). No gaps are apparent.

Complex tools with many parameters or behaviors need more documentation. 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 (limit) is fully described in the schema with range and default, and the description adds no parameter-specific semantics. With 100% schema coverage, the baseline of 3 applies.

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

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

The description clearly defines the tool as 'the product timeline' and enumerates the specific content types (drafts, ships, skips, scans, observations, decisions with their rationale) and ordering (newest first). It distinguishes this from sibling getters by emphasizing the collective agent/founder history rather than a single 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?

It explicitly instructs to 'Read before acting so you never redo recent work,' giving a clear when-to-use. It stops short of naming alternatives or when-not conditions, but the guidance is specific 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 already declare readOnlyHint and destructiveHint, and the description reinforces this with 'Read-only, free' while adding useful context about 'the founder's own edits' and the included metric battery. This goes beyond the structured 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, front-loads the core purpose, and packs in the metric list and usage guidance without fluff. Every clause serves a purpose.

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

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

For a parameterless read-only tool with no output schema, the description adequately covers the data returned (metrics), the usage trigger (competitor/outreach work), and safety (read-only/free). It is complete for its 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 input schema is empty (0 parameters), and the description confirms no arguments are needed. With no parameters to document, the baseline score of 4 applies; the description adds no unnecessary parameter noise.

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

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

The description clearly identifies the tool as providing 'the competitor roster with the measured stat battery' and enumerates specific metrics (performance, SEO, Core Web Vitals, etc.). This distinguishes it from sibling tools like get_seo or get_scoreboard by centering on competitors as the 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 explicitly instructs to 'Read before any competitor or outreach work so a rival is never treated as a pitch target,' giving clear when-to-use context. It does not name alternative tools or exclusion scenarios, 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 and destructiveHint, and the description reinforces these with 'Read-only'. It goes beyond annotations by listing the concrete return fields and adding the credit-metering note, which gives the agent a clearer picture of behavior.

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

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

The description is compact: one sentence with a clear list of returned fields, followed by two short fragments about credits and read-only/free. There is no fluff or repetition, and the most important information 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 covers the essential context: what data is returned, that it is a read-only operation, and a note about future metering. It could be more explicit about what 'product run summary' means or when to use this tool, but for a simple getter it is largely complete.

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

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

The tool has zero parameters, so there is no parameter semantics to explain. The description lists output fields instead, which is useful context in lieu of an output schema, though it doesn't directly address parameters.

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

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

The description clearly identifies the tool as returning a product run summary with a specific set of fields (product_url, tier, trial_ends_at, etc.), which distinguishes it from sibling getters. However, the term 'product run summary' is not immediately obviously synonymous with 'enrollment', so it could be more explicit.

Agents choose between tools based on descriptions. A clear purpose with a specific verb 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 no guidance on when to use this tool versus alternatives. It only states properties like 'Read-only, free' and lists output fields, but does not mention any context where this tool should be preferred or avoided.

Agents often have multiple tools that could apply. Explicit usage 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 the return detail ('full markdown body') and the note 'Read-only, free,' which confirms the safety profile and adds the 'free' (no cost) aspect beyond annotations. This is useful context for an agent deciding whether to invoke the 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?

The description is two sentences, front-loaded with the core action and output, followed by a concise secondary sentence about slug provenance and read-only/free nature. No unnecessary words or repetition of the tool name. Every part adds value.

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

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

For a simple read-only tool with one parameter and no output schema, the description covers the input (slug from list_kb_pages), the output (full markdown body), and the use case. It does not detail error cases or response structure beyond the body, but it's sufficient for a low-complexity 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% with a single required parameter 'slug' described as 'The page slug, from list_kb_pages.' The description repeats this source ('Slugs come from list_kb_pages') but adds no new syntax or format details. With the schema fully documenting the parameter, the description provides marginal additional value, so baseline 3 is appropriate.

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

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

The description clearly states the tool's function: fetching a single Memory page by slug with its full markdown body. It distinguishes itself from siblings by referencing list_kb_pages as the source of slugs and specifying its role as the record the growth marketing engine drafts from.

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

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

The description gives clear usage context: slugs come from list_kb_pages, implying a prerequisite step. It also states the tool's purpose ('the record the growth marketing engine drafts from'), which helps the agent decide when this read operation is appropriate. It doesn't explicitly mention alternatives or exclusions, but the relationship to list_kb_pages provides practical guidance.

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

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

Annotations already declare readOnlyHint=true and destructiveHint=false. The description adds meaningful context by explaining that the tool exposes provisioning status, autonomy levels, and the runnable_loop_types accepted by run_loop, including the prerequisite that loops must be enabled. This goes beyond the annotations without contradicting them.

Agents need to know what a tool does to the 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, with two sentences and no fluff. The first sentence is a bit dense with parenthetical examples, but the second sentence earns its place by clarifying the runnable condition. Overall it is efficient and front-loaded with the main resource.

Shorter descriptions cost fewer tokens and are easier for agents to parse. 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 should indicate what the response contains, and it does: provisioned loops, autonomy level, and runnable_loop_types. The optional loop_type filter is already documented in the schema. It could be more explicit about response format, but for a simple read-only status tool it is sufficiently complete.

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

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

Schema coverage is 100% with a clear description for loop_type ('Optional loop type, e.g. daily_brief or linkedin_post'). The description does not add any extra meaning about the parameter beyond what the schema already provides, so the baseline score of 3 is appropriate.

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

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

The description identifies the resource (automated growth marketing loops) and the information returned (autonomy level, runnable_loop_types), making the tool's purpose reasonably clear. However, it lacks an explicit verb like 'returns' or 'lists', and the phrase 'what run_loop accepts' can be slightly confusing. It does differentiate from siblings like run_loop and set_loop_autonomy by focusing on status.

Agents choose between tools based on descriptions. A clear purpose with a specific verb 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 by stating 'A runnable type only runs once a loop of that type is provisioned and enabled here,' which suggests checking this tool before using run_loop. However, it does not explicitly state when to use this tool versus alternatives, nor does it mention exclusions. This is helpful but implicit guidance.

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

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

Annotations already declare readOnlyHint=true and destructiveHint=false, but the description adds substantial context: it lists the full set of returned fields (drafted body, evidence, receipt, criteria, founder's voice samples), notes the conditional tracked_link field, and clarifies that this operation never mints a new move. This goes well 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 a dense single paragraph that front-loads the core purpose and then enumerates the returned components. While it is longer than minimal, every phrase carries information (content, conditional field, workflow, read-only status). It is somewhat run-on but remains scannable and free of 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 must explain return values, and it does thoroughly: it lists all relevant fields, explains the conditional tracked_link, and situates the tool in a workflow ('Read it before writing any move, then ship_move'). This is complete for a single-parameter, 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?

The input schema covers 100% of parameter semantics: move_id is described as 'Move id (uuid), from list_feed or get_standup.' The description does not add any parameter-specific details, but it doesn't need to because the schema is already explicit. 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 opens with 'One growth move in full: everything needed to write its deliverable yourself,' which clearly specifies the verb (get), resource (growth move), and scope (full detail). It also distinguishes from siblings like ship_move by stating 'this door reports one, never mints one' and positions itself as a read-before-write step.

Agents choose between tools based on descriptions. A clear purpose with a specific verb 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 'Read it before writing any move, then ship_move once the founder is happy,' which provides a direct when-to-use instruction and names the alternative (ship_move) for the next step. It also clarifies that tracked_link is reported, not created, reinforcing that this tool is for reading existing moves.

Agents often have multiple tools that could apply. Explicit usage 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 useful behavioral context beyond annotations: the specific data elements returned and the recommended call sequence ('after ship_move'). It does not detail return format, but for a 0-param read-only tool this is sufficient.

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

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

Two concise sentences. The first front-loads the output contents, the second states usage and safety. 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?

Given the simple tool (0 params, no output schema, good annotations), the description is complete enough. It lists the key returned data categories and provides the lifecycle context (after ship_move), allowing an agent to select and invoke the tool correctly.

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

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

The tool has 0 parameters and the schema is empty, so description has nothing to explain. Per the baseline for 0 params, a score of 4 is appropriate. The description does not need to add parameter details because there are none.

Input schemas describe structure but not intent. Descriptions should explain 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 what the tool returns: tracked-link clicks per move, shipped counters, weekly movement scoreboard, and connection status for GA4/Search Console. It uses a specific verb+resource and distinguishes itself from sibling tools (e.g., get_scoreboard, get_output) by focusing on outcomes of shipped 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 says 'Call it after ship_move', providing clear context for when to use the tool. It does not mention alternatives or exclusions, but the temporal constraint and 'Read-only, free' signal are strong usage guidance.

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

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

Annotations already declare readOnlyHint=true and destructiveHint=false, so the safety profile is established. The description adds value by noting the tool is free, and that it returns the full content body—behavioral details not present in annotations. No contradictions with annotations.

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

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

The description is extremely concise—two short sentences that immediately convey the tool's purpose, expected input origin, and return content. No filler or redundancy; every word earns its place.

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

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

For a simple one-parameter read tool with no output schema, the description covers the purpose, the return content (full body), and the source of ids. It lacks details about error behavior (e.g., not found), but given the tool's simplicity and the presence of annotations, this is adequate and only slightly incomplete.

Complex tools with many parameters or behaviors need more documentation. 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 documents output_id as a uuid with 100% coverage. The description adds meaningful provenance by stating ids come from list_outputs, which helps the agent understand how to obtain a valid parameter value. This goes beyond the schema's basic type/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 clearly states the tool retrieves a single drafted marketing output by id, with its full content body. This distinguishes it from list tools like list_outputs and other get_* siblings by emphasizing the single-output scope and the inclusion of the full 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?

It explicitly notes that ids come from list_outputs, which implies the intended workflow (use list_outputs to obtain ids, then get_output). It does not explicitly exclude alternative tools or state when-not-to-use, but the contextual clue is strong enough for a simple read 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 declare readOnlyHint true and destructiveHint false, and the description reinforces that with 'Read-only, free.' More importantly, it explains the meaning of like_for_like (true/false/null) and warns never to present a delta as a result when like_for_like isn't true, adding significant interpretive 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 moderately long but well-structured: it starts with a framing question, lists the report contents, then gives the essential like_for_like rule. Each sentence earns its place, though the like_for_like explanation is somewhat verbose.

Shorter descriptions cost fewer tokens and are easier for agents to parse. 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 one parameter and no output schema, the description provides a solid mental model of what the return includes (visibility at both ends, moves, scans, receipts) and how to interpret the key field. It doesn't describe exact output formatting, but that's not essential for an overview tool with good annotations.

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

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

The single parameter window_days is fully documented in the schema (range, default, clamping behavior) with 100% schema coverage, so the description doesn't need to repeat it. The description adds no parameter-specific semantics beyond the schema, but the schema itself is sufficiently complete.

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

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

The description opens with 'Did the growth work move anything?' and clearly defines the resource as a proof read covering AI visibility at start/end of the window, moves shipped, scans, and receipts. This makes it a distinct period-over-period growth scoreboard, easily distinguishable from siblings like get_visibility or get_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?

The use case is implied through the framing question and the detailed like_for_like caution, but the description doesn't explicitly name alternatives or state when not to use this tool. It gives clear context for interpretation after calling, but lacks direct guidance on tool selection relative to 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?

Annotations already declare readOnlyHint=true and destructiveHint=false. The description adds valuable context beyond this: it is 'free,' describes the output contents (issue groups, trend, performance, etc.), and states that seo_fix moves are 'minted from it.' No contradiction with annotations, and it enriches understanding of what the tool provides.

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

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

The description is three sentences: content summary, usage recommendation, and parameter tip. It is front-loaded with what the tool does, efficient, and every sentence earns its place with no fluff.

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

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

For a simple one-parameter, read-only tool with no output schema, the description is thorough. It covers the return content, usage timing, relationship to other tools, read-only/free nature, and parameter usage. No significant 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 a clear description: 'Include the per-page audit detail. Default false: the grouped issues only.' The description's 'Pass include_pages for the per-page detail' is redundant but reinforces the parameter's purpose. It adds no new semantic meaning beyond the schema.

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

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

The description clearly states the tool's function: 'The site-wide SEO audit: issue groups with severity and affected pages, the weekly score trend, page performance, links and authority, and day-0 search ranks.' It uses a specific verb-resource relationship ('get_seo' returns an SEO audit) and distinguishes itself from siblings by focusing on this audit and its role in minting seo_fix 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 says when to use: 'Read before any SEO work of your own; the Feed seo_fix moves are minted from it.' This gives clear context and prerequisite positioning. While no alternatives are named, the tool's unique role in the SEO workflow makes the guidance 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. The description adds meaningful context by explicitly stating 'Free, read-only' and explaining that the snippet only provides documentation content, not modifications. It also clarifies the intended workflow (show to founder, add with consent), going beyond the annotation's safety flags.

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

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

The description is two sentences, front-loaded with the main purpose. The first sentence is long but packs essential detail about the snippet's content; the second gives a clear action. It is not overly verbose, though it could be split for better readability.

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

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

For a tool with no parameters and no output schema, the description fully covers what the tool does, what the snippet contains, usage instructions, and cost implications. It leaves no significant gaps for an agent to understand when and how to invoke 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?

The tool has zero parameters, so the baseline is 4. The description adds value by explaining what the returned snippet contains, even though there are no parameter semantics to clarify. Since schema coverage is vacuously 100%, no additional parameter info is needed.

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

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

The description clearly states the tool returns a paste-able 'Growth (AfterLaunch)' section for CLAUDE.md or AGENTS.md, specifying its content (how to use AfterLaunch for growth, marketing, SEO, GEO, competitors, distribution) and distinguishing it from sibling tools that fetch specific data or perform actions.

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

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

It explains when to use the snippet (when setting up AfterLaunch guidance for coding agents) and provides a clear instruction to show it to the founder and add it only with their approval. It also notes the tool is free, implying safe usage, though it does not explicitly compare to 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, and the description reinforces with 'Read-only, free.' Beyond annotations, it adds behavioral context that the data is stable and not live, which helps the agent understand the nature of the response. It doesn't contradict annotations, and the additional context is valuable.

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

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

The description is two sentences, front-loaded with the core content and immediately followed by a sharp usage alternative. Every word earns its place, with no redundancy or fluff.

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

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

For a zero-parameter, read-only tool with no output schema, the description is complete. It covers what the snapshot contains, clarifies it's stable, provides a pointer to live alternatives, and mentions read-only/free nature. No gaps remain 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 has zero parameters, matching the empty schema exactly (schema coverage 100%). With no parameters, the description doesn't need to explain parameter meanings; the baseline of 4 applies since the schema is fully self-explanatory.

Input schemas describe structure but not intent. Descriptions should explain 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 Growth Snapshot, enumerating specific components (positioning, discoverability score, prioritised leverage actions, competitor set, day-0 SEO/AI baselines). It also distinguishes it from live-data sibling tools by calling it 'stable business context.' This is a specific verb+resource definition that effectively separates it from similar-sounding tools like get_visibility and get_seo.

Agents choose between tools based on descriptions. A clear purpose with a specific verb 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 provides use context: it is the stable snapshot from the product run, and it directly names alternatives for live signal data ('use get_visibility and get_seo'). This gives clear when-to-use and when-not-to-use guidance.

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

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

Annotations already declare readOnlyHint=true and destructiveHint=false, and the description reinforces this with 'Read-only, free'. It adds behavioral context about the content (e.g., 'capped at the account's age', 'never a second copy of ready') and mentions the deep scan status, providing more transparency 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, dense sentence but well-structured with parenthetical clarifications. Every clause adds value, though it could be slightly more scannable. Still, it is appropriately sized for the amount of 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?

Without an output schema, the description carries the burden of explaining what the tool returns. It does this well by listing all sections (receipts, ready, needs_you, while_you_were_gone, deep scan status) and implying a 'message' field to relay. Minor gaps remain about exact format, but overall it is complete enough for an agent to understand the tool's role.

Complex tools with many parameters or behaviors need more documentation. 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 schema coverage is trivially 100%. The description compensates by explaining the output sections, which is helpful given there is no output schema. No parameter semantics needed.

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

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

The description clearly identifies the tool as a daily standup summary aggregating multiple data points (receipts, ready, needs_you, while_you_were_gone, deep scan status). It uses a specific verb ('standup') and distinguishes itself from sibling tools by explicitly naming list_feed and positioning itself as the session-start 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 description gives explicit usage instruction: 'Call this at the START of a session, before list_feed'. It also tells the agent to relay the message field, which is a clear action guideline. This is strong guidance for when and how to use the tool.

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

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

Beyond the readOnlyHint and destructiveHint annotations, the description adds meaningful behavioral context: the sampling count's statistical implications ('treat a change as indicative unless it says otherwise'), the 'Read-only, free' note, and the sequencing dependency on refresh_scan. This is substantial value 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 succinct yet dense, condensing a large amount of information into a few sentences. Every clause serves a purpose: defining the output scope, qualifying data reliability, directing workflow, and explaining the optional parameter. No fluff or redundancy.

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

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

Despite lacking an output schema, the description enumerates all major output components (engine answers, share of voice, sources, gaps, trend, crawlability, off-site reach) and explains the sampling caveat. It also covers the single parameter and its effect. For a read-only, relatively simple tool, this is complete enough for an agent to set expectations.

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

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

Schema description coverage is 100%, so the baseline is 3. The description echoes the schema's guidance ('Pass prompt_id to drill into one question') without adding new semantic detail beyond what the schema states, so no bonus is warranted.

Input schemas describe structure but not intent. Descriptions should explain 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 specifies the resource and action: 'The measured AI visibility (GEO) results' with detailed constituent elements (engine answers, share of voice, cited sources, gaps, trends, crawlability). It distinguishes from siblings like get_seo by focusing on AI visibility/GEO rather than traditional SEO or other analytics tools.

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

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

Provides explicit workflow context: 'Read after refresh_scan and before any AI visibility or GEO work,' which tells when to use it. It also gives conditional usage via the prompt_id parameter ('Pass prompt_id to drill into one question'). However, it does not explicitly state alternatives or when not to use it, stopping 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?

Adds valuable behavioral context beyond annotations: describes row-level states (connected, not_connected, not_available) including reasons for unavailability. This enriches the readOnlyHint and destructiveHint annotations without contradiction.

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

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

Four short sentences, each earning its place: purpose, output structure, usage guidance, and safety note. Front-loaded with the core purpose, no redundancy or fluff.

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

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

For a no-parameter, read-only listing tool, the description is fully complete. It covers what is listed, the exact output states, and usage context, making it self-sufficient even without an output schema.

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

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

The tool has zero parameters and the schema is empty, so the baseline is 4. The description adds context about the scope of data (specific channels) but no parameter-specific semantics are needed.

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

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

The description clearly states the tool lists connected growth data sources and distribution channels, naming specific services (GA4, Search Console, Google Business Profile, LinkedIn/Reddit). This distinguishes it from siblings like start_connection and disconnect_connection.

Agents choose between tools based on descriptions. A clear purpose with a specific verb 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 instructs to read this tool before start_connection to avoid offering impossible connections, providing a clear when-to-use directive. It also notes the tool is read-only and free, further guiding safe usage.

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

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

Annotations already declare readOnlyHint=true, and the description adds that the tool is read-only. It also discloses behavioral details not in the schema: drafted bodies are excluded by default, has_draft indicates their presence, and live moves are returned unless include_resolved is passed. The 'since' behavior is also explained. Slight lack of detail on ordering/pagination, but this is minor given the annotations.

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

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

The description is compact yet information-dense. Each sentence serves a distinct purpose: what it lists, when to use it, where to get the body, and how to filter. No filler or redundancy.

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

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

No output schema exists, but the description enumerates the returned fields and explains the default live-only behavior, include_resolved, and since semantics. It also directs users to get_move for the full body, making the tool's role in the workflow clear. Could be slightly more explicit about ordering, but 'ranked' implies 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 100%, so the parameters are fully documented. The description adds a small amount of context for 'since' (new moves while deep scan fills the board) and clarifies verbosity defaults, but it does not significantly go 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 tool lists a ranked backlog of growth marketing moves with specific fields (title, why, area, status, rank, has_draft) and covers multiple categories. It distinguishes itself from get_move by explicitly noting that drafted bodies are not included.

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

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

Provides explicit when-to-use guidance ('Read it before improvising growth work of your own'), points to the alternative tool for the body ('call get_move'), and explains the use of include_resolved and since parameters for filtering. This 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 already declare readOnlyHint=true and destructiveHint=false. The description adds 'Read-only, free' (free being new) and clarifies that output consists of summaries with a size hint, giving useful behavioral context 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 two sentences long and packs relevant context (what the pages are, output format, alternative for full bodies). The parenthetical list of example pages is somewhat heavy, but overall it is compact and front-loads key info.

Shorter descriptions cost fewer tokens and are easier for agents to parse. 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, the description adequately communicates what the tool returns (summaries) and how to get more detail (get_kb_page). No output schema exists, but the simple nature of the tool means this is sufficient, though it doesn't specify pagination or field details.

Complex tools with many parameters or behaviors need more documentation. 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 the baseline is 4. The description does not need to add parameter details, and none are expected for a simple list operation.

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

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

The description clearly identifies the resource (Memory pages) and what the tool returns (summaries with a size hint), and distinguishes from the sibling tool get_kb_page for fetching full bodies. However, it lacks an explicit verb like 'lists' or 'lists summaries', relying on the tool name 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 explicitly states when to use this tool (to get summaries) and directs to an alternative for full content: 'fetch a body with get_kb_page'. This provides clear distinction and usage context.

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

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

Annotations already cover read-only and non-destructive behavior, and the description reinforces this with 'Read-only, free.' It adds valuable behavioral context: the output is ordered newest first, includes only specific metadata fields, and lacks the body content—information not available from annotations alone.

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

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

The description is compact and efficiently front-loaded, covering the resource, ordering, fields, a cross-reference to a sibling tool, and safety status in just two sentences. Every clause provides meaningful 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 zero parameters, no output schema, and strong annotations, the description fully covers what the tool does, what it returns, and how to use it in context. It explains the exact data fields and the relationship to get_output, making it complete for a simple list tool with no additional 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 input schema has zero parameters, so there is no parameter documentation needed. The description still adds value by specifying the output fields, which helps users understand what each returned item contains, despite no schema-level parameter semantics to clarify.

Input schemas describe structure but not intent. Descriptions should explain 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 defines the tool as listing drafted marketing and distribution content for the product, specifying the exact fields returned and the ordering (newest first). It also distinguishes itself from get_output by pointing to that tool for fetching the body, 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?

Provides clear context for when to use this tool (to list metadata for drafted content) and explicitly directs users to get_output for the body, implying this tool is not for retrieving full content. It doesn't explicitly mention when not to use other list tools, but the product-specific scope and field list give sufficient guidance.

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

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

Annotations already declare readOnlyHint=true and destructiveHint=false, but the description adds substantial context: prompts returned in tracking order, a hard cap of 15, a 'used' count, the meaning of the 'curated' flag (false means auto-generated and replaceable), and that it's free on every plan. This exceeds the annotation coverage.

Agents need to know what a tool does to the 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 packed with useful information in three sentences, but the first sentence is a slightly awkward fragment ('The buyer questions AfterLaunch tracks...') that could be more grammatically fluid. Every sentence earns its place, though.

Shorter descriptions cost fewer tokens and are easier for agents to parse. 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 explaining key return fields (prompts, tracking order, cap, used, curated) and when to use it. However, the meaning of 'used' is not fully explicit (likely a count, but not stated), and the structure of each prompt (e.g., text vs ID) is unaddressed, 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?

The tool has zero parameters (empty schema), so there are no input semantics to clarify. The description doesn't need to compensate for parameter gaps, and the 0-param baseline of 4 applies.

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

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

The description clearly states the tool returns the tracked buyer questions for AfterLaunch's AI visibility (GEO) measurement, with a specific verb ('Returns') and details on the data structure (order, cap, used, curated). It distinguishes itself from mutating siblings like track_prompt and untrack_prompt.

Agents choose between tools based on descriptions. A clear purpose with a specific verb 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 instructs to read this tool before track_prompt or untrack_prompt to avoid duplicate questions and to know remaining capacity. This provides concrete when-to-use guidance and rationale relative to 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?

While annotations already indicate readOnlyHint=true and destructiveHint=false, the description adds valuable behavioral context: it is idempotent ('nothing is spent or consumed'), free, and reports specific state values. It also implies retry behavior with 'wait poll_after_seconds and ask again', going beyond the annotation baseline.

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

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

The description is three concise sentences, front-loaded with the core question and purpose. Every sentence adds functional information (usage instruction, possible states, idempotency) with no filler or redundancy.

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

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

Given the tool's simplicity (one parameter, no output schema), the description fully covers what the agent needs: what it does, how to invoke it, all possible return states, and safety/behavioral notes. There are no significant gaps for selecting and using this tool correctly.

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

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

The schema already provides a complete description for the single parameter (poll_token: 'The poll_token start_connection returned.'). The tool description merely repeats this instruction without adding new meaning, so it meets the baseline for high schema coverage without additional 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 uses a specific verb 'poll' with a clear resource 'connection' and states the exact purpose: checking whether the founder finished connecting a growth data source. It lists the possible outcomes (pending, connected, expired, not_found), which clearly distinguishes it from siblings like start_connection or 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?

The description gives explicit context: use the poll_token returned by start_connection, and provides guidance for handling the 'pending' state (wait poll_after_seconds and ask again) and 'expired' state (mint a fresh link). It does not explicitly name alternatives, but the usage scenario is so specific that the intended workflow 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 state readOnlyHint=false and destructiveHint=false, which are minimal. The description adds critical behavioral context: 'Recording the same insight twice replaces your earlier note; a pinned note is left as it is,' revealing the overwrite behavior. It also mentions the required 'act' scope and describes the exact return value ('the top of their board with move ids'), going far 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 long but every sentence carries operational weight. It is front-loaded with purpose, then structured with 'WHEN:' and 'WHAT COMES BACK:' markers, making it scannable. A slight deduction for density—some sentences could be tightened without losing value—but overall the structure is strong.

Shorter descriptions cost fewer tokens and are easier for agents to parse. 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 covers all critical context: the trigger condition, exclusions, persistence semantics (replace, pinned note), required scope, character limits, and return value. The task is complex enough that this thorough disclosure is appropriate and fully complete.

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

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

Schema coverage is 100%, so the baseline is 3. The description adds qualitative guidance beyond the schema: insight should be 'one plain sentence in the founder's own terms, 10 to 500 characters,' which reinforces and shapes the parameter semantics. It also enumerates the four kinds in the 'kind' parameter via examples in the 'WHEN' section, adding context not fully captured in the schema.

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

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

The description opens with 'Write one durable thing you have learned about this founder or their product into AfterLaunch's Memory,' using a specific verb ('write') and resource ('Memory'). It clearly distinguishes from siblings like get_snapshot and get_kb_page by explicitly saying not to record restatements of those tools.

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

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

Provides explicit 'WHEN' guidance: 'the moment the founder tells you something that will still be true next month and that AfterLaunch could not have measured itself.' It also gives exclusions: 'Never record chatter, a passing mood, a restatement of get_snapshot or get_kb_page, or anything you inferred rather than heard.' This is a model of when-to-use 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?

Description discloses valuable behavioral traits: refusal of placeholders/broken links, retention of previous draft as revision history, and requirements (free, 'act' scope, Founder tier). These go beyond annotations and align with them (annotations: readOnlyHint false, destructiveHint false).

Agents need to know what a tool does to the 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 four concise sentences, each adding value: purpose, manual-only constraint, refusal conditions/revision history, and requirements. No redundant or filler content.

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

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

Covers purpose, constraints, behavior, and auth requirements for a simple 2-parameter tool. Lacks mention of return value or success/error response, which would be helpful given no output schema, but the description is otherwise 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% with both parameters fully described in the input schema. Description adds no additional parameter-level meaning beyond what schema already states, so baseline 3 is appropriate.

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

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

Description clearly states 'Replace a drafted marketing output's body' with a specific verb and resource, and adds 'before it is shipped' for scoping. It differentiates from sibling update_draft by explicitly saying 'Manual replacement only: the AI redraft stays in the app.'

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

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

Provides clear context: tool is for manual replacement before shipping, and implies not for AI-generated drafts. However, it does not name alternative tools or provide explicit when-not-to-use conditions beyond refusing placeholders/broken links.

Agents often have multiple tools that could apply. Explicit usage 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 the sparse annotations (readOnlyHint=false, destructiveHint=false) by explicitly warning 'SPENDS MONEY,' requiring a paid plan/trial, and detailing rate limits (daily/monthly caps, one scan per type per product per day) and idempotent replay behavior on repeat attempts.

Agents need to know what a tool does to the 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 compact, information-dense paragraph with every sentence earning its place: cost warning, purpose, prerequisites, limits, and idempotency behavior. It is appropriately front-loaded with 'SPENDS MONEY' and wastes no words.

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

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

The description thoroughly covers operational details (cost, scope, idempotency, rate limits, per-day behavior) that are essential for safe use. However, it does not describe what the tool returns or how to retrieve the scan result (e.g., via get_visibility), which is a noticeable gap given the absence of an output schema.

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

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

Schema coverage is 100% with both parameters fully described in the schema. The description adds no new parameter information—it merely repeats the scan value and idempotency-key requirement in prose. Baseline 3 is appropriate since the schema already carries the explanatory burden.

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

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

The description clearly states the tool's verb ('run'), resource ('an on-demand AI visibility scan'), and the exact scan type ('ai_visibility'). It explains the purpose (GEO measurement of answer engines) and distinguishes it from a read-only alternative like get_visibility by emphasizing it's a paid refresh operation.

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

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

The description provides strong usage context: requires 'write' scope, a paid plan or trial, an Idempotency-Key, and is bounded by credit/caps. It does not explicitly name alternatives or say 'when not to use,' but it implies this is a deliberate, cost-incurring action rather than a routine read.

Agents often have multiple tools that could apply. Explicit usage 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 openly discloses that the operation 'SPENDS MONEY', requires specific auth scopes, uses an idempotency key, and is bounded by credit balance and rate caps. These details go far beyond the simple readOnlyHint and destructiveHint annotations, providing excellent behavioral transparency.

Agents need to know what a tool does to the 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 and front-loaded, with 'SPENDS MONEY' as an immediate warning. Each sentence adds essential information: purpose, prerequisites, limits, and frequency. There is no redundancy or filler.

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

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

The description covers the tool's purpose, prerequisites, costs, and limits thoroughly. However, it does not mention the return value or whether the operation is synchronous/asynchronous, which would be useful given there is no output schema. Still, it is complete enough for a simple trigger action.

Complex tools with many parameters or behaviors need more documentation. 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 fully documents the single parameter idempotency_key with a description ('Client-minted key (1-200 chars)'). The tool description only repeats 'an Idempotency-Key you mint' without adding new meaning, so the baseline of 3 for high schema coverage 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 identifies the action ('run the growth-move generator on demand to top up the Feed') with specific resources (Feed, marketing moves) and domains (SEO, AI visibility, competitors, distribution). This distinguishes it from sibling tools like list_feed or run_loop, making the purpose unambiguous.

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

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

The description provides strong context: it is for on-demand top-ups, requires write scope and a paid plan/trial, and is subject to daily/monthly caps and a once-per-day-per-product limit. It does not explicitly name alternative tools, but the prerequisites and constraints effectively guide 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 discloses critical side effects beyond the minimal annotations: 'SPENDS MONEY', costs 1 credit, requires write scope, is capped, and has idempotent replay behavior. This provides the agent with the consequences of invocation, which the 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 dense but efficient; every sentence adds essential information (cost, scope, caps, idempotency, eligibility). It is front-loaded with the 'SPENDS MONEY' warning. No fluff.

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

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

For a money-spending mutation tool with no output schema, the description covers the action, cost, prerequisites, limits, and acceptance criteria. It could mention the return value or failure modes, but it still provides enough for an agent to decide 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?

The schema already documents both parameters with descriptions, but the description adds important semantics: the idempotency_key must be client-minted, and repeats replay at no cost regardless of key. It also clarifies that loop_type must be a provisioned, runnable type, enriching the schema's simple examples.

Input schemas describe structure but not intent. Descriptions should explain 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: 'trigger one on-demand generation run of a growth marketing loop' and gives concrete examples (linkedin_post, geo_improvement, competitor_intel). It distinguishes from sibling tools like set_loop_cadence and get_loop_status by focusing on the on-demand execution.

Agents choose between tools based on descriptions. A clear purpose with a specific verb 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 usage context: requires 'write' scope, idempotency_key, is bounded by caps, and only accepts runnable, provisioned loop types (referencing get_loop_status). It explains the one-run-per-cycle idempotency behavior, which informs when to reuse keys. However, it doesn't explicitly name alternative tools for scheduling or other operations, so it stops short of full when-not-to-use 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?

With readOnlyHint=false already indicating mutation, the description adds valuable behavioral context: the required scope and tier, and a critical constraint that social/distribution channels are always human-reviewed rather than autonomous. This goes 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 consists of exactly two sentences, each contributing distinct value: purpose, requirements, and an exception. It is tightly packed with no filler words, making it easy for an agent 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?

For a two-parameter setter with no output schema, the description covers purpose, authentication, and channel-specific constraints. It does not define what each autonomy level does behaviorally in detail, but the enum names and the 'does on its own' context give sufficient guidance. A 5 would require explicit explanation of each level's effect.

Complex tools with many parameters or behaviors need more documentation. 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 describes loop_type with an example but does not describe the 'level' enum's semantics. The description compensates by enumerating the levels (review, one_click, autonomous) and explaining their high-level meaning, plus adding the social-channel restriction. This meaningfully augments the 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?

The description uses the specific verb 'Set' and the noun 'how much a growth marketing loop does on its own', clearly identifying the resource and action. It distinguishes from siblings like set_loop_cadence, which configures the schedule 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 states explicit prerequisites: requires the 'config' scope and Founder tier. It also provides a when-not condition by specifying that social and distribution channels never accept 'autonomous'. However, it does not explicitly name alternative tools, so it falls just short of a 5.

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

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

Beyond the annotations (readOnlyHint=false, destructiveHint=false), the description adds valuable behavioral details: permission requirements, the speed constraint, and that 'default' clears any override. This enriches the agent's understanding of side effects and limitations 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?

The description is three sentences, each with a distinct purpose: core function, requirements, and behavioral constraint. No wasted words, and the most important information is front-loaded.

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

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

For a simple two-parameter tool with no output schema, the description covers purpose, requirements, constraints, and reset behavior. It lacks explicit alternative tool references, but overall it is sufficient for an agent to select and invoke the tool correctly.

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

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

The description explains the cadence values (including the reset behavior of 'default') and implies the loop_type parameter via 'growth marketing loop'. With 50% schema coverage, this adds meaningful context beyond the raw schema, especially for the cadence enum.

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

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

The description clearly states the tool's function with a specific verb ('Set') and resource ('growth marketing loop'), and enumerates the exact cadence values. It also differentiates from sibling tools like set_loop_autonomy and run_loop by focusing on cadence scheduling.

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

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

The description provides clear context for when to use the tool by specifying required scope ('config') and tier ('Founder'), and imposes a key constraint (only slow/pause, never speed up). It does not explicitly name alternatives or when-not-to-use cases, but the context is strong enough to guide correct usage.

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

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

Beyond the annotations (readOnlyHint=false, destructiveHint=false), the description discloses that this never actually posts to a channel, that reporting the outcome is mandatory, and that it requires 'act' scope and Founder tier. These behavioral traits are not captured in annotations and add crucial context for an agent.

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

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

The description is front-loaded with the core purpose and then expands with usage and transparency details. It is slightly verbose but every sentence adds meaningful value, with no filler. Could be trimmed slightly, but structure is logical.

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

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

Given the tool's simplicity (2 params, no output schema), the description is fully complete: it explains the action, when to use each option, the absolute prohibition on self-initiated shipping, the requirement to report true outcomes, permission/scope needs, and the distinction from approve_output. 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 description coverage is 100%, so the schema already documents both parameters thoroughly. The description reinforces the meaning of action values and ties output_id to list_outputs, but does not add new semantic details 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?

The description clearly states the verb 'Resolve' and the resource 'drafted marketing output in the founder's review queue', and explicitly contrasts with sibling approve_output for publishing. It distinguishes the two actions 'ship' and 'skip', making the purpose unmistakable.

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

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

The description provides explicit WHEN guidance: call 'ship' only when the founder confirms with their go, never on your own; call 'skip' when they decide against it. It also names the alternative for real publishing (approve_output), offering strong usage direction.

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

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

Annotations already indicate this is not read-only and not destructive. The description adds valuable context: it is free to set, returns a cost quote, and omitting the level performs a read-only action. It also explains the effect on confidence bands, which is beyond annotation data.

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

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

The description is four sentences with no redundancy. Each sentence adds distinct information: purpose, effect, scope/cost, and read behavior. It is front-loaded with the core action.

Shorter descriptions cost fewer tokens and are easier for agents to parse. 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 tool with no output schema, the description covers purpose, level semantics, effect, cost implication, and read/write modes. It is complete enough 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?

The schema already covers the single parameter (level) with 100% coverage, so baseline is 3. The description adds meaning by mapping l1/l2/l3 to 'standard', 'deep', 'exhaustive' and explaining the trade-off with confidence band, enriching schema 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 purpose: setting how deeply AI visibility scans measure, with specific levels l1/l2/l3 explained. It differentiates from siblings like get_visibility and refresh_scan by focusing on intensity configuration, and the read-mode behavior is also distinguished.

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

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

The description gives clear context on when to use this tool (to adjust scan depth) and explains the omit-level read behavior. However, it does not explicitly mention alternatives or when not to use it, though the sibling tool names imply this is the only intensity setter.

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

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

Annotations already indicate a non-read-only, non-destructive mutation. The description adds crucial behavioral context: shipping is a human decision, reporting is the agent's non-optional duty, after-launch measurements depend on the report, and a receipt_url will be returned when a tracked link exists. This goes far beyond the annotation profile without contradicting it.

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

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

Though it is a longer description, every sentence contributes essential operational nuance: the when, the exclusions, scope requirements, optional param, and return value. It is front-loaded with the core purpose, then structured to cover exceptions and constraints without redundancy.

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

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

The tool has only two parameters and no output schema, yet the description still explains the return behavior (receipt_url) and all relevant lifecycle rules. It differentiates from skip_move and provides decision-making context, making it complete for an agent to invoke correctly.

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

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

Schema description coverage is 100%, so baseline is 3. The description adds value by clarifying the conditional use of asset_url ('Pass asset_url when the move published a live asset'), which the schema does not fully convey. While move_id is straightforward, the added conditional guidance elevates the score.

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

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

The description opens with a specific verb and resource: 'Mark a growth move shipped', and explicitly references 'the same action as Ship in the Feed' for clarity. It also distinguishes from sibling skip_move by stating that turned-down moves go there, making the purpose unmistakable.

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

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

Provides explicit WHEN: 'call it the moment the founder confirms the work is actually live, with their go and never on your own.' It also states exclusions (drafted/staged/awaiting review are not shipped) and names the alternative tool skip_move for rejected moves. This is model guidance for when to use this vs 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 indicate readOnlyHint=false and destructiveHint=false. The description adds the 'act scope' requirement and notes that feedback improves future marketing drafts, providing behavioral context beyond the annotations. It does not contradict annotations and adds value by explaining the learning loop effect.

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

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

The description is two concise sentences, front-loaded with the action. It includes only essential information without fluff, making it easy to parse quickly.

Shorter descriptions cost fewer tokens and are easier for agents to parse. 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 skip action, the description covers the operation, cost, required scope, and feedback effect. It does not mention return value or reversibility (undo is implied via sibling), but this is not critical for basic invocation given the provided annotations and schema.

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

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

Schema coverage is 100%, with each parameter already described in detail (move_id, feedback_key enum, feedback_note maxLength). The description only restates the purpose of feedback_key/note, adding no extra semantic value 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 verb 'Dismiss' and the resource 'growth move', with a clarifying parenthetical '(Skip in the Feed)'. This distinguishes it from siblings like archive_move and undo_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?

Provides useful context such as 'Free' and 'requires the act scope', but does not explicitly mention when alternatives like archive_move or undo_move should be used. The sibling names make the distinction fairly clear, but no direct exclusions are given.

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

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

Beyond the annotations (readOnlyHint=false, destructiveHint=false), the description discloses key behaviors: the link is bound to the founder's session, the assistant never completes consent, the link expires in 15 minutes, refusal happens before minting, and the operation is free. This is rich behavioral transparency that helps the agent set expectations.

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

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

The description is front-loaded with the core purpose and then adds necessary details (returned fields, expiration, polling step, refusal condition) in a compact, well-organized way. Every sentence contributes meaningful 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 tool's simplicity (1 parameter, no output schema), the description is complete. It explains the return values, the timeout, the follow-up polling step, and the failure condition, so the agent knows exactly what to expect and what to do next.

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

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

The input schema already provides 100% coverage for the single 'provider' parameter, including which provider IDs to use (ga4, gsc, gbp, linkedin, reddit) and that they come from list_connections. The description adds no additional parameter-level details, 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 clearly states the verb ('Connect') and resource ('a growth data source or distribution channel'), and explains the unique mechanism (minting a one-time link for the founder to approve). It distinguishes itself from siblings like poll_connection and disconnect_connection by describing the consent flow.

Agents choose between tools based on descriptions. A clear purpose with a specific verb 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 context: it says to hand the url to the founder, then poll_connection until connected. It also mentions the refusal case for shut connectors. It does not explicitly name alternatives like 'use list_connections to find provider IDs' but references it indirectly through provider ids, and the flow is clear enough.

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

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

Beyond the annotations (readOnlyHint=false, destructiveHint=false), the description discloses significant behavioral traits: it is free, it causes the next scan to run at full depth, it re-baselines the week-over-week trend, and it requires config scope and Founder plan. It also explains the free-trial behavior and how to upgrade. This transparency goes well 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 dense but well-structured. It front-loads the core purpose, then covers consequences, constraints, and requirements. Every sentence adds value, though it is longer than strictly necessary. The information is organized logically, making it easy for an agent 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 that the tool has only one parameter, no output schema, and modest annotations, the description fully compensates by explaining side effects, prerequisites, free-trial behavior, and the hard cap. It is complete for an agent to invoke the tool correctly and anticipate the impact of doing so.

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

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

The input schema already provides a full description of the 'text' parameter with length constraints. The tool description adds extra semantics: questions are deduplicated, there is a hard cap of 15 total questions, and it must be phrased as a real buyer question. This complements the schema rather than merely repeating 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?

The description opens with a specific verb+resource: "Add one buyer question to the AI visibility (GEO) set." It clearly distinguishes this tool from siblings like untrack_prompt (removing) and list_tracked_prompts (listing). The scope and constraints (e.g., 10-200 characters, hard cap of 15) further solidify its purpose.

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

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

The description states when to use the tool (to add a buyer question) and provides context on side effects and prerequisites, advising to "add deliberately rather than churning the list." It also mentions using create_checkout for upgrades on a free trial. However, it does not explicitly name alternatives like untrack_prompt or list_tracked_prompts for other use cases, so it misses a clear 'when not to use' 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 only indicate non-readOnly and non-destructive. The description adds meaningful context: cost ('Free'), required scope ('act'), idempotency, side-effect boundaries (channel publish stays posted), and limitations (archived/expired cannot be restored). This exceeds 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?

Three sentences, each dense with purpose and constraints. No fluff, and the most important action (restore to pending) is front-loaded. 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?

Covers key behavioral aspects, side effects, and limitations. The absence of an output schema is mitigated by stating idempotency, but it doesn't explicitly describe the success return or error cases, leaving a small 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% for the single parameter move_id, with a clear description in the schema. The tool description does not add additional parameter semantics, 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 starts with a specific verb+resource+outcome: 'Restore a just-shipped or just-skipped growth move to pending'. It clearly distinguishes this tool as the self-correction for ship_move and skip_move, setting it apart from siblings like archive_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?

It explicitly states when to use: for a wrong ship_move or skip_move. It also gives when-not: 'It never unwinds a real channel publish' and 'an archived or expired move cannot be restored'. While no alternative tool is named, the scope is well defined for the decision.

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

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

The annotations only set readOnlyHint=false and destructiveHint=false, which add little. The description compensates fully by disclosing the side effects (next scan runs at full depth, trend re-baselines), matching semantics (case/punctuation insensitive), idempotency, and access requirements. This is rich behavioral 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 dense but efficient, with four sentences covering purpose, consequences, matching, idempotency, and requirements. Every sentence adds value, and the main action is stated first. No redundancy or fluff.

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

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

The tool is simple (one parameter, no output schema), and the description covers all essential aspects: what it does, side effects, matching behavior, idempotency, prerequisites, and cost. It references track_prompt for consequences but also states them inline, so no missing information.

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

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

The schema has 100% coverage: the 'text' parameter is described as 'The tracked question to remove, from list_tracked_prompts. Matched ignoring case and punctuation.' The description repeats the matching logic but does not add new semantic meaning. Since the schema already documents the parameter well, 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 ('Remove one buyer question from the AI visibility (GEO) set') and the purpose ('freeing a slot against the cap of 15'). It distinguishes this from the sibling `track_prompt` by implication (removal vs. addition) and specifies the exact resource being modified.

Agents choose between tools based on descriptions. A clear purpose with a specific verb 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 (used to remove tracked questions) and prerequisites (requires 'config' scope and Founder plan). It references track_prompt for consequences, which implies the alternative, but does not explicitly state when not to use it. Still, the usage scenario 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?

The description discloses auth requirements ('requires the ''act'' scope'), cost ('Free'), and validation behavior ('refused rather than saved'). These go beyond the annotations, which only indicate non-read-only and non-destructive.

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

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

Three sentences, each carrying distinct information: purpose, validation behavior, and cost/scope. No redundant words.

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

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

With simple parameter set and annotations, the description covers the core operation, constraints, and preconditions. It doesn't specify return value, but that's a minor gap for an update operation.

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

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

Schema covers both parameters with descriptions (move_id from list_feed, draft_content 1-20000 chars). The description adds no extra semantic 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 uses the specific verb 'Replace' and identifies the resource as 'a pending growth move's marketing draft body before shipping,' clearly distinguishing it from sibling tools like redraft_output or ship_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?

It provides clear temporal context ('before shipping') and implies the tool is for updating drafts of pending moves, but it doesn't explicitly 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?

The description adds behavioral context beyond the readOnlyHint annotation, such as feed_ready being false while the deep scan builds and credits only available once metering is live. This helps the agent understand the asynchronous nature of certain returned fields and plan accordingly. No contradiction with annotations.

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

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

The description is a single, dense sentence that front-loads the purpose and packs in relevant details. It is efficient, though slightly overloaded with multiple clauses; splitting it into two sentences could improve readability without losing information.

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

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

Given no output schema, the description thoroughly covers the expected return values (product run, scopes, tier, trial_ends_at, feed_ready, credits) and the timing of their availability. It also provides usage context that makes the tool's role clear in the broader workflow.

Complex tools with many parameters or behaviors need more documentation. 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 an empty input schema, there is no need for parameter explanation. The baseline for a zero-param tool is 4, and the description adds value by explaining the returned fields instead, which 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's function: 'Confirm the AfterLaunch key works' and enumerates the specific information it returns (product run, scopes, tier, trial_ends_at, onboarding, credits). This distinguishes it from sibling tools by establishing it as an identity/context check to be called first.

Agents choose between tools based on descriptions. A clear purpose with a specific verb 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 instructs 'Call this first' before any growth or marketing work, and provides additional timing guidance (wait for feed_ready before reading the Feed, credits once metering is live). This clearly indicates when to use the tool and sets expectations for subsequent actions.

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