ProductClank

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

Annotations only clarify that the tool is not read-only, not destructive, and not open-world. The description adds that the effect is granting view/manage access, but it does not mention possible side effects like repeated calls creating duplicate delegates, account/permission prerequisites, or whether an existing delegate is replaced. That is an adequate baseline but not a rich behavioral disclosure.

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

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

Two sentences deliver the action, outcome, cost, and target use case efficiently. The one-word fragment 'Free.' carries relevant economics without detracting from the overall structure.

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 only two simple string parameters and no output schema, the description covers the required context: what the tool does, who it can add, and when it is useful. It lacks details about return values or error cases, but these are less critical for this call shape.

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 only 50% schema description coverage because campaign_id lacks a schema description, the description compensates by referring to the campaign and calling it 'agent-created'. For user_id, the description adds beyond the schema by noting that the connected user's own id can be used. This meaningfully helps an agent choose parameters correctly.

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

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

States a specific verb and resource: 'Add a ProductClank user as a delegate on a campaign', with a clear outcome ('so they can view and manage it from the webapp's My Campaigns page'). The title reinforces the primary effect, and no sibling tool overlaps with the act of granting delegate access.

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

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

Gives clear when-to-use context: 'Useful to hand oversight of an agent-created campaign to its human owner', and even covers the edge case of self-delegation ('the connected user's own id works too'). It does not name alternatives, but there are no obvious sibling tools dedicated to this task, so exclusions are less necessary.

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?

It goes far beyond the annotations by disclosing credit costs per action, platform-specific limitations, the quote-post display mechanism, platform auto-detection, and the mandatory user-confirmation step. This is rich behavioral context for a mutating 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 dense but efficient; every clause contributes operational detail. It front-loads the core purpose, then delivers costs, platform matrix, optional product behavior, and a safety instruction without 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 mutating tool with no output schema, this description covers inputs, costs, platform support, optional parameters, and user confirmation. The only minor omission is the return value, but the schema and behavioral detail are rich enough that an agent can 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?

Even though the schema covers 100% of parameters, the description adds essential semantics: per-action credit costs, platform restrictions, optional product_id behavior, and reply_guidelines scope. This materially improves an agent's ability to choose and populate parameters correctly.

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

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

The description clearly states the specific verb-resource relationship: create a boost campaign that spends credits to drive engagement on a given social post. It distinguishes itself from content-creation and campaign-management siblings by focusing on boosting an existing post via community engagement. Platform and action-type details reinforce the tool's unique scope.

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

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

The description gives strong contextual guidance: when to link a product, when to omit it, which platforms support which actions, and the instruction to confirm cost with the user. However, it never explicitly contrasts boost_post with alternatives like create_campaign or generate_posts, so the agent must infer when to prefer this tool over 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 mark it read-only, and the description adds valuable context about the plan and credit costs, exceeding the baseline 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?

Three concise sentences, with the core action and resource front-loaded and supporting cost details placed after. 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?

There is no output schema, so the description should indicate what is returned. It specifies 'credit balance and plan' and gives usage context, which is adequate for an agent to understand the outcome, though it omits concrete field names or format.

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

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

No parameters exist, so schema coverage is trivially complete. The description adds no parameter meaning but does not need to; the tool operates on the connected user by default.

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

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

Description clearly states the verb 'Return' and the resource 'credit balance and plan', and it specifies the user scope. It is distinct from sibling campaign-management tools, as none other directly checks balance.

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 use before launching a campaign and provides exact credit costs for different campaign types, leaving no ambiguity about when this tool is appropriate.

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

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

The description goes well beyond the annotations: it spells out credit costs, background research, the private/public posting distinction, per-post billing, reversibility, server-side rejections for platform-specific params, and that platform is fixed after the first post. This is exactly the behavioral context an agent needs before calling.

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 and information-rich, with no obvious waste, and it front-loads the core purpose. However, it is presented as one long paragraph, which makes the critical pre-call instructions and cost details harder to scan quickly; a structured breakdown would improve usability.

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

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

For a complex 13-parameter tool with no output schema, the description covers preparation steps, dependencies, costs, defaults, side effects, and post-call follow-up actions such as reading research before generating posts. It is remarkably 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?

Although schema description coverage is high at 92%, the description adds meaningful guidance: how to derive keywords and search_context, what platform to pick and why, visibility defaults, and the practical meaning of target_subreddits / target_youtube_channels. It enriches 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 states a specific verb and resource: 'Create a Communiply discovery campaign' that finds social posts by keyword and drafts product-mentioning replies. This clearly distinguishes the discovery campaign from content-campaign siblings, and the title reinforces the same 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 gives strong when-to-use guidance: derive keywords from the product site, iterate before spending, confirm costs, and choose between private/public modes. However, it does not explicitly route the agent away from an alternative sibling like create_content_campaign, so it stops short of fully naming alternatives and exclusion conditions.

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

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

Annotations declare readOnlyHint=false, destructiveHint=false, and openWorldHint=false, so the core safety profile is already clear. The description adds that the tool spends 1000 credits (a critical behavioral trait not in annotations), and auto-activates the campaign. However, it does not mention whether the action is reversible, what happens to unused credits, or if there is a confirmation step beyond user prompt. With no destructive hint, the description could more explicitly state that this is a write-only action that cannot be undone.

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 (4 sentences), front-loads the core purpose, and each sentence adds distinct value: what the tool does, credit cost, automation behavior, prerequisites, and usage steps. 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 7 parameters (2 required), no output schema, and moderate complexity, the description covers the core workflow (prerequisite, preview, cost, activation). It is complete enough for an agent to use correctly. Minor gap: it does not mention what happens after activation (e.g., how to track results), but the description 'community submissions and winner selection happen in ProductClank web app' provides sufficient closure.

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

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

Schema description coverage is 100%, so the baseline is 3. The description adds that campaign_message is a 'core brief' and that the AI expands the brief, but does not explain how other parameters like references or additional_guidelines interact. It does not add syntax or domain-specific details beyond what the schema already provides. Overall, the description adds marginal value over 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 verb ('launch') and resource ('content campaign'), and specifies the unique scope: rallying a community to create content (posts, threads, videos). It differentiates from siblings like suggest_content_campaign (preview) and boost_post (separate action), and explicitly mentions the required product_id from search_products.

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 recommends using suggest_content_campaign for preview first and confirms the 1000-credit cost before calling. It also states the need for a product_id from search_products. However, it does not explicitly state when not to use this tool or compare to other siblings like write_content_candidates, which could be an alternative for creating content.

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 write operation (readOnlyHint=false) and non-destructive (destructiveHint=false). The description adds significant behavioral context: it is free ('FREE — no credits charged'), it auto-fills fields from the URL with override behavior, it deduplicates ('reuses an existing listing... rather than duplicating'), and it returns the product id. No contradiction with annotations.

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

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

The description is concise (few sentences), front-loaded with the core purpose, and each sentence adds unique value. No redundancy. It efficiently covers purpose, usage, behavior, and parameters without 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 tool's complexity (8 parameters, no output schema, but 100% schema coverage), the description covers all crucial aspects: what it does, when to use it, the auto-fill mechanism, dedup behavior, free nature, and return value (product id). It also warns about confirming with the user. No gaps remain for effective invocation.

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

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

Schema coverage is 100% with 8 parameters all described. The description goes beyond by stating that 'At minimum pass a url' and that 'the server auto-fills the name, tagline, description, logo, and X handle from the site; any field you pass explicitly overrides what's extracted.' This adds semantics about parameter relationships and defaults that are not in the schema, making it highly informative.

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 action ('List a new product on ProductClank') and its key characteristic ('token-free listing'). It also distinguishes itself from the sibling tool 'search_products' by specifying the use case ('when search_products finds no existing match'). The verb 'list' combined with the resource and context makes the purpose 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 explicit guidance: 'Use this when search_products finds no existing match and the user wants to run a boost or campaign for a product that isn't listed yet.' It also instructs the agent to 'Confirm the product details with the user before calling,' giving a clear prerequisite. This effectively contrasts with siblings like 'boost_post' (which requires an existing product).

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 accurately states read-only behavior, which matches the readOnlyhint annotation, and adds useful behavioral details beyond it: free, newest-first ordering, types of transactions included, and the fact that in-connector top-ups are unavailable. It does not contradict the annotations, but it also does not go deep into response shape or edge behaviors.

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

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

Three short, purposeful sentences, each doing useful work: one states what the tool is, one states its intended use, and one gives the key out-of-band transaction steps. The description is front-loaded with the primary identity and does not waste 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 two self-describing optional params and the very helpful readOnlyhint annotation, the description covers the main things an agent needs: what data it affects, why to call it, and the external fallback to a purchase URL. It does not go into output shape, but because there is no output schema, listing transaction categories and order is reasonably complete for this simple history 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 two params are optional limit and offset, whose names are fairly self-descriptive. The schema documents the limit default and bounds, leaving offset semantics implicit. The description's 'newest first' adds context for reading the list but does not explain pagination, so the description adds only marginal value beyond the schema.

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

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

The description clearly states that this returns the connected user's credit transactions (purchases, campaign spend, participation rewards), newest first. It is specific about the resource and ordering, and it is easy to tell apart from siblings like check_balance, though it does not explicitly name an alternative tool for the same 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 says to use it to account for spent or earned credits, which gives a clear intended use case. It also tells the caller that top-ups are not available in-connector, routing users to an external purchase URL when balance runs low. It does not explicitly address when check_balance should be used instead, but the usage guidance is still reasonably 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?

Beyond the annotations (readOnlyHint=false, destructiveHint=false), the description discloses an important refusal condition (already_claimed), platform character limits, and that the edit becomes what gets posted. It does not address errors or persistence details, but the main behavioral risks are covered.

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

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

The description is three sentences, front-loads the core action, and every sentence carries distinct information: what it edits, when to use it, and constraints/refusals. No filler or repetition of the schema.

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

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

For a simple three-parameter mutation tool with minimal annotations and no output schema, the description supplies enough context to invoke it correctly, including a key failure condition and length limits. The only minor gap is that campaign_id is not explained, but this is shared campaign context rather than tool-specific behavior.

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

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

With two of three parameters described in the schema, the description adds meaning by tying reply_id to get_posts, framing reply_text as a full replacement, and adding X/other character limits. The campaign_id parameter remains undocumented, but the context is mostly recoverable from the campaign workflow.

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

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

The description names a specific verb and resource ('Rewrite the text of ONE reply draft') and clarifies scope with 'before the community posts it' and 'exact reply a creator will claim.' This distinguishes it from generation/publishing siblings without needing to open the schema.

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

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

'Use it when the user wants different wording on a specific draft from get_posts' states the triggering condition explicitly, and 'Refuses a reply a creator has already claimed ... edit before you publish' provides a clear when-not-to-use constraint. This gives an agent actionable routing guidance.

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

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

The description states the operation is 'Free, read-only', matching the readOnlyHint annotation and adding an explicit guarantee. It also discloses the tool's return scope: every active public campaign plus campaigns from communities the user belongs to, with each item clarifies the difference between content and take_action campaigns. It does not cover pagination or infrequent details, but the annotations already establish a safe read operation.

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, giving the core behavior first: 'every active public campaign plus campaigns from the user's communities'. It then adds useful kind details and workflow guidance without waste. 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?

This is a simple, read-only listing with two optional parameters described in the schema, so the description no need extensive output details. The description covers what is returned, the kind distinction, and the recommended next step. An agent can safely call this tool and interpret the results correctly.

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

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

The input schema already has 100% coverage with descriptions for 'kin d' and 'lim it', so the baseline is 3. The description does not add additional meaning about the parameters beyond the schema's info; it discusses 'kind' in terms of results rather than filtering.

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

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

The description clearly states the tool's purpose: discovering campaigns the connected user can join and earn from, including active public campaigns and community campaigns. It also defines the 'content' versus 'take_action' kind distinction. However, it does not explicitly differentiate this tool from the similarly broad siblings 'find_opportunities' or 'list_campaigns'.

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 this tool — the user wants campaigns they can participate in and earn from. It also gives a workflow signal by directing the agent to follow with 'get_campaign_brief'. It does not explicitly mention when not to use this tool or name alternatives like 'list_campaigns' or 'find_opportunities'.

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 explicitly says 'Free, read-only' and describes the tool as browsing unclaimed drafts, which aligns with the readOnlyHint annotation. It also clarifies that proof of likes/reposts stays in the web app, adding behavioral context beyond the 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?

The description is front-loaded with the main purpose and organized into a clear browse-then-submit flow. It includes some extra context about screenshots and the web app, which is useful but makes the text slightly longer than strictly necessary.

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

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

With no output schema, the description compensates by explaining that each opportunity contains a real social post, pre-drafted text, platform, and actionType. It also covers the follow-up submission step and reward attribution, giving the agent enough context to call the tool and interpret results.

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

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

The schema describes limit and campaign_id, and the limit default is mentioned. Offset is not described in the schema or the narrative, though its purpose is reasonably inferable from the name and pagination context. The description adds no additional parameter-level detail beyond the schema.

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

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

The description clearly states the tool browses unclaimed drafts from active campaigns the connected user can earn from, with each item described as a real social post plus pre-drafted text. This specific verb and resource scope distinguish it from sibling generation, submission, and campaign management 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?

The description gives a clear flow: pick an opportunity, post it, then call submit_participation with the URL. It also explains the handle-linking requirement for reward attribution. It does not explicitly contrast with alternative tools, but the workflow guidance is sufficient for correct usage.

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

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

Annotations confirm side effects (readOnlyHint=false) and open-world interaction, but the description enriches this with concrete behavioral specifics: 12 credits per post, typical 5–20 posts, a few minutes duration, and the need to confirm the cost with the user. These are genuinely useful and not present in 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 three tight sentences that front-load the core operation, then give the critical cost and workflow details. No sentence is wasted, and the length matches the needed complexity.

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

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

For a state-changing, cost-incurring tool with no output schema, the description covers the full critical path: what it does, cost, time, user confirmation, and which sibling tools to use for reading and pruning results. Nothing essential for correct invocation is missing.

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

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

The schema lists only campaign_id with zero description coverage. The description's phrase 'the campaign's discovery pipeline' implies campaign_id identifies which campaign to use, but it does not explain the parameter further, its expected format, or where to obtain it. Some meaning is added, but at 0% schema coverage the description could compensate more.

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

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

The description clearly states the tool runs the campaign's discovery pipeline, scrapes social platforms for matching posts, and drafts community replies. This gives a specific resource and action that distinguishes it from later reading (get_posts) and pruning (review_posts), even though it does not explicitly name alternative discovery tools like find_opportunities.

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 tells the agent to check_balance first, confirm the spend with the user, and then follow with get_posts and review_posts. This is clear contextual guidance on prerequisites and follow-up actions, but it does not explicitly state when not to use the tool or compare with alternate discovery/research tools.

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

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

Annotations already mark this as read-only, so the bar is lower; the description adds meaningful context by mentioning 'live stats', 'free', and the categories of data returned. It does not contradict the readOnlyHint and gives useful behavioral 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 tightly written and front-loaded with the core purpose. Every sentence adds unique information with 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?

With no output schema, the description compensates by naming the returned content: configuration fields and live stats. It could be marginally richer on exactly what status values appear for replies, but for a one-parameter read 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?

The schema already documents campaign_id fully as 'Campaign UUID (from list_campaigns or create_campaign)' with 100% coverage. The description adds no new 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 names a specific verb and resource ('Get one campaign's configuration') and lists exactly what is returned, differentiating it from list_campaigns and other campaign-related tools. It is impossible to mistake this for a list or write 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 explicitly tells the agent when to call it: after generate_posts or before adjusting the campaign. It does not state formal exclusions or compare direct alternatives, but for a single-resource read tool this 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?

Annotations provide readOnlyHint=true and openWorldHint=false, but the description adds meaningful behavior: 'Free, and it never scrapes — safe to call at the start of every session.' It also discloses the default time window (last 24 hours) and the incremental behavior via `since`. No contradiction with annotations.

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

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

Three tight sentences: purpose first, then safety/usability, then usage pattern. Every sentence earns its place with no fluff. The most critical info (incremental cursor) is front-loaded with `since`. Perfectly structured for quick agent scanning.

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

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

For a 3-param tool with no output schema, the description gives a clear overview of return content (posts, replies, links, engagement), usage scope (across chats), and a pointer to the cumulative sibling. Combined with readOnlyHint, an agent has everything needed to call it correctly and integrate it into a multi-step 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?

Schema covers 2 of 3 parameters (67%), but the description enriches `since` significantly by tying it to the previous call's `checked_at` and explaining omit behavior. The missing campaign_id is self-evident. Since the description compensates for the gap and adds real semantic depth, it earns a 5.

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

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

States a specific verb and resource: 'Catch up on a campaign since the last check' and enumerates the exact return content (posts, replies, LIVE links, engagement). It clearly distinguishes from siblings like get_campaign_results by naming it explicitly for cumulative data, making purpose unambiguous.

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

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

Explicitly says to use this to resume a standing growth operation across chats, then get_campaign_results for the cumulative picture. Also advises calling at the start of every session and explains how to use `since` for incremental checks. Clear when/why and points to an alternative.

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?

Find_occasions sets readOnlyHint:true; resets is read-only and free. It further describes non-obvious behavior: externally linked instructions must be fetched and followed, and that the tool implies a downstream submission step. This is valuable behavioral context beyond what annotations already reveal. It does 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 well-sized, starts with the essence, and uses a compact list to convey many required elements. The second sentence adds contextual instruction without over-inflation, although the last sentence includes downstream steps that are not strictly performed by this tool.

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?

Since the tool has no output schema, the description carries responsibility and adequately enumerates return value: campaign action message, sections, content types, eligibility criteria, judging, rewards, deadline, and remaining submission limit. It also warns about external instruction links, making it reasonably complete for the task of consuming the brief.

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

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

Schema coverage is 100% and the single parameter already explains that campaign_id comes from find_open_campaigns. The description adds no extra parametric semantics such as formatting, ownership, or relationship to the user granted submission state.

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 is a full participation brief for one campaign and enumerates its contents (action message, sections, judging criteria, rewards, deadline, submissions left). This is more specific than a generic read-only campaign tool, though it does not explicitly compare itself to the sibling get_campaign, so it stops just short of full sibling distinction.

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 communicates the flow around the tool: read the brief, follow any external instructions, then work with the user and submit_campaign_work. That is a clear context, but the overall purpose describes a workflow when it should be used before submission, and unlike a direct alternative, it does not offer any differentiation from sibling campaign/brief tools. Explicit 'when not to use' guidance is also absent.

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 openWorldHint=false, so the description is not required to repeat safety. It adds value by disclosing that the tool is free and never scrapes, and that it costs nothing to poll, which informs an agent about rate-limit or cost implications. This goes beyond the annotations and provides useful behavioral context 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?

The description is thorough and well-structured, front-loading the funnel details and then the cost/usability question. It is slightly verbose but every sentence adds meaningful information—the funnel stages, metrics, cost breakdown, and usage context. It does not waste words on redundancy, so it earns a 4.

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 reporting tool with a single parameter and no output schema, the description is quite complete. It enumerates all the data points the agent can expect, explains the cost model, and gives a usage scenario. The only missing piece is an explicit statement about the required campaign_id parameter and its format, but the rest is sufficient for an agent to call the tool correctly.

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

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

Schema coverage is 0% (the schema has no descriptions for parameters), and the description does not mention the campaign_id parameter at all. Although the parameter is self-explanatory from its name, the description fails to compensate for the lack of schema documentation. The agent would have to infer that campaign_id refers to the target campaign ID, which is a gap given the low 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 states exactly what the tool does: it returns a cumulative scorecard for a campaign, enumerating the full funnel and metrics (approval rate, survival, engagement, credits spent, cost per usable reply). This is a specific verb+resource and is clearly distinct from the sibling tools, despite not naming them directly. The phrase 'unlike the web report' hints at an alternative without explicit differentiation, but the purpose is unambiguous.

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

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

The description provides a clear use case: 'Use it to answer "is this working and what am I paying for it?"' which guides when to call it. It also contrasts with the web report for cost and scraping behavior. However, it does not explicitly state when not to use it or name specific sibling alternatives, so it lacks explicit exclusions but is still helpful.

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

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

Annotations already declare readOnlyHint=true and openWorldHint=false, but the description adds real behavioral context: 'free' (no cost), safe to poll, and the transient 'processing' state with zero submissions immediately after launch. That post-launch state guidance is the kind of trait annotations cannot express, though return shape/pagination semantics are not covered.

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

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

Front-loaded with what the tool produces, then the safety/cost note, then the interpretive caveat about 'processing', and finally accepted identifier forms. Four sentences, each carrying distinct information with no wasted phrasing.

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

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

With no output schema, the description compensates by enumerating the returned fields (submission counts, live links, review states, winners), and it covers the 4-parameter surface via 100% schema coverage. An agent has enough to call it correctly and interpret a fresh-campaign result.

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

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

Schema description coverage is 100%, so limit, offset, status, and campaign_id are already fully documented in the schema. The description's note that it accepts a UUID or public campaign number largely duplicates the campaign_id schema text and adds no syntax or format detail the schema lacks; baseline 3 is appropriate.

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

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

States a specific verb and resource and enumerates exactly what it returns (submission counts, live content links, approval/rejection state, winners), which is more than the name or title conveys. It also distinguishes itself from the sibling get_campaign_results by anchoring to 'content campaign' and tying to create_content_campaign.

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

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

Gives clear usage context: use it to close the loop on create_content_campaign, it is safe to poll, and the 'processing' + zero-submissions state right after launch is expected rather than a failure. It does not explicitly state when not to use it or name a competing sibling to route to, so it stops short of a 5.

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

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

Annotations already declare readOnlyHint=true, so safety is covered. The description adds useful behavioral context beyond annotations: the tool is FREE, and it explains what each status value means including the default 'active'. It does not mention pagination or empty-queue behavior, but this is minor given the read-only nature.

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 return contents, then usage contexts, then status semantics. It is somewhat long but every sentence adds value; the status enumeration is informative rather than filler.

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

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

For a simple read tool with no output schema, the description covers the main return fields, intended use cases, cost implication (FREE), and status semantics. Missing details like default limit, ordering, or how to interpret verdict are not critical but would make it 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_description_coverage is 0%, so the description must compensate. It does a good job explaining the 'status' parameter, including the default and each enum value's meaning. However, it does not explain the 'limit' parameter's semantics or default behavior, and 'space_id' is left entirely to its name and the schema's required marker.

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

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

The description clearly states a specific verb and resource: reading the space's content queue, and enumerates the returned fields (text, platform, status, reviewer score/verdict/fix). It also differentiates itself from siblings by framing this as the user-facing 'All Content' view and explicitly connecting to write_content_candidates, making its role distinct from other getters.

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

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

The description explicitly says when to use it: to present drafts for approval one by one and to read back scores after write_content_candidates. It does not provide when-not-to-use guidance or name alternative tools, so it stops short of the top tier.

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

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

Beyond the readOnlyHint annotation, the description discloses that the tool is FREE, lists the content of the workspace, and explains the meaning of enabled:false—that the space has no content engine yet. This gives the agent actionable behavioral knowledge about how to interpret the response.

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

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

The description is three sentences with no filler: it front-loads the return contents, then adds the FREE signal and usage guidance, then the key enabled:false branch. Every sentence earns its place.

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

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

For a simple single-parameter read tool with no output schema, the description is complete: it tells the agent what data will come back, when to retrieve it, and how to interpret the critical enabled flag. No essential behavior is missing.

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

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

Schema description coverage is 100%, and the single parameter space_id is already documented as coming from list_content_spaces or any Amplify space the user owns. The description adds context about the workspace contents but does not need to add parameter-level detail. Baseline 3 is appropriate.

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

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

The description opens by naming exactly what the tool returns: the brand's voice, platforms, post types, playbook, review threshold, topic inventory, and style guides for one content space. This clearly distinguishes it from siblings like list_content_spaces (listing spaces) and setup_content_space (creating/updating a space).

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 to read this BEFORE writing any draft and at the start of any content conversation. It also provides a conditional follow-up: if enabled:false, offer setup_content_space, which tells the agent when not to proceed with writing and what sibling to invoke instead.

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

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

Beyond the readOnlyHint=true annotation, the description adds 'Free' and explicitly repeats 'read-only' with the phrase 'Free, read-only.' It also clarifies scope (connected user, work submitted via this connector) and the exact data categories returned. 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?

A single, well-structured sentence is front-loaded with the main deliverable ('participation totals') followed by a compact list of the exact data elements. Every phrase earns its place — no filler, no repetition of the title beyond the core verb.

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

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

The tool is a simple 0-parameter read-only operation with no output schema. The description fully covers purpose, scope, return contents, cost, and safety. Nothing an agent needs to decide when to call it and what it will receive is missing.

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

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

The tool has zero parameters and the schema coverage is 100% with no required fields, so the description carries no burden on parameter semantics. The baseline of 4 applies because no parameters need clarification.

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 clear verb-plus-resource pattern: it returns 'the connected user's participation totals' and enumerates exactly what's included (points, credit balance, reply stats with statuses). It also scopes the data to 'work submitted through this connector,' which distinguishes it from sibling tools like check_balance or credit_history.

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: when you need the connected user's participation totals and reply stats. It doesn't explicitly name alternatives or state exclusions, but the specificity of 'participation... submitted through this connector' implies the intended use case well 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?

The description complements the readOnlyHint annotation by adding 'read-only' and 'free', and by disclosing the returned statuses and reviewer notes. It does not exhaustively describe edge cases, but for a read-only status lookup the behavioral transparency is adequate.

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

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

The description is two sentences: the first front-loads the exact resource and output content, the second adds the usage context. There is no redundant boilerplate, and the most important information appears early.

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 purpose, result content, read-only nature, and the recommended call flow after submit_campaign_work. Since there is no output schema, a slightly more explicit return-shape description would help, but for a low-complexity read-only tool this 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 schema only provides a required string parameter with no description (0% coverage). The phrase 'to one campaign' indirectly clarifies that campaign_id identifies the campaign, but the description does not explicitly map the parameter or explain where the identifier comes from, so it only partially compensates for the missing schema documentation.

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 ('connected user's submissions') and scope ('to one campaign') and enumerates exactly what the tool returns: pending / approved / rejected states plus reviewer's notes. This is enough to distinguish it from siblings like get_campaign or list_campaigns.

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 an explicit trigger: 'Use to report outcomes back to the user after submit_campaign_work.' This is clear and actionable, though it does not explicitly name alternatives or conditions when not to use the tool.

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

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

The readOnlyHint annotation already covers safety; description reinforces with 'Read' and adds that it is 'Free'. It does not disclose return format or pagination behavior, but these are less critical given 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?

Description is concise two-sentence summary that front-loads the object of the operation and immediately supplies workflow context. Every sentence serves a distinct 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 simple read tool, the description plus schema is mostly usable, but with no output schema and low parameter documentation, it leaves the agent to infer details about status filtering, pagination, and exactly what the response contains. It is adequate but not complete.

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

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

Schema description coverage is only 40%, and the description adds no parameter-level detail. It implies campaign_id ('a campaign's') and posts, but limit, offset, status, and include_replies are not explained 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?

Description clearly states a read operation on 'a campaign's discovered posts with their drafted replies', making the resource and purpose unambiguous. It differentiates from siblings by naming generate_posts, review_posts, and regenerate_replies in a workflow, so an agent can immediately see this is the inspection 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?

Explicit guidance says to use this after generate_posts and before review_posts/regenerate_replies. This establishes a clear place in the workflow, though it does not mention alternatives like get_research or list_campaigns when campaign context is unclear.

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

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

Beyond the readOnlyHint annotation, the description adds meaningful behavioral details: it is free of charge, and it reports which findings are actually applied (expanded keywords/exclusion terms always active, others dormant until enabled). This provides operational nuance that annotations alone do not convey.

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

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

The description is two compact sentences with no filler. The main purpose is front-loaded, and additional behavioral nuances are efficiently appended. Every sentence contributes valuable 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?

The tool is simple (one parameter, no output schema), but the description fully explains what it returns (cached analysis), how the findings are interpreted (active vs dormant), and how to influence them (via update_campaign). It also notes the free cost, covering all needed context for an agent to decide and call it.

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

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

With 0% schema description coverage, the description carries the burden for the 'campaign_id' parameter. It mentions 'for a campaign' but does not elaborate on the ID's format, source, or relationship to other campaign tools. This is minimal compensation, though acceptable for a simple identifier.

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

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

The description clearly states the tool reads cached research ('Read the cached topic/competitor analysis for a campaign'), specifying the resource and linking it to a specific source ('from run_research'). It distinguishes itself from sibling tools like get_campaign and run_research by narrowing the scope to cached analysis results.

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 it should be used after run_research has been called, and explicitly mentions update_campaign as the way to enable dormant findings. However, it does not explicitly name alternatives or state when not to use this tool, leaving some inference to the agent.

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

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

Annotations already mark the tool as read-only, and the description adds useful behavioral context: results are newest first, the list includes campaigns created outside this connector, and the tool is free to use. There is no contradiction with the readOnlyHint annotation. It does not mention pagination, but that is a minor gap for a read-only listing 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 compact and efficient: a single clear sentence defines scope and ordering, followed by a short workflow note and a one-word cost indicator. There is no redundant or filler content.

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

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

For a simple read-only listing tool with no required parameters and no output schema, the description provides enough context to use it correctly: what it lists, in what order, and why. It could clarify how limit, offset, and status combine or what the response looks like, but those are inferable and largely covered by the schema's enum and default values.

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

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

Schema description coverage is only 33%, and the description does not explain limit, offset, or status. It implies unfiltered 'ALL' behavior and ordering, but leaves parameter semantics to the schema. Since coverage is low, the description needed to compensate and did not.

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 ALL of the connected user's discovery/boost campaigns, names the ordering (newest first), and emphasizes its comprehensive scope across both the connector and ProductClank web app. It also places the tool in a workflow by saying it is used to find a campaign id before get_campaign / generate_posts / get_posts, which distinguishes it from those siblings.

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

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

The description explicitly gives a concrete use case: find a campaign id before calling get_campaign, generate_posts, or get_posts. It does not explicitly state when to avoid this tool in favor of other list-like siblings such as find_open_campaigns, but the 'ALL' scope and stated workflow make the primary usage clear.

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

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

Annotations already declare readOnlyHint=true and openWorldHint=false. The description adds valuable behavioral context: it lists only spaces with content engine enabled, owned/delegated/managed by the user, and the specific return schema. This goes beyond annotations, and there is no contradiction.

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

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

The description is two sentences with no wasted words. It front-loads the purpose and provides actionable guidance in a compact format. 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?

Given the tool's simplicity (no parameters, no output schema), the description covers everything needed: purpose, eligibility criteria, return fields, and usage sequencing. It tells the agent to resolve the space_id for a sibling tool and confirm with the user, which is complete for this listing operation.

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

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

The tool has zero parameters, so there is no need for the description to add parameter meaning. The input schema is empty, and schema description coverage is 100% by default. The description does not add parameter info (not needed), but it does clarify the output structure. A score of 4 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 'List', the resource 'ProductClank content spaces you can draft into', and includes specific constraints (user ownership/delegation/management, content engine turned on). It also mentions the return fields { space_id, name }, making the purpose unambiguous and distinct from sibling tools like write_content_candidates or boost_post.

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 advises to 'Call this first to resolve the space_id for write_content_candidates, and confirm the target space with the user.' This tells the agent exactly when to use this tool (as a prerequisite for write_content_candidates) and includes a user confirmation step, providing 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?

The description adds meaningful behavior beyond the annotations: add is capped at 12 topics, omitted keywords are auto-proposed, update with is_active:false keeps a topic but stops using it, remove deletes it, and suggest generates KB-grounded ideas distinct from existing topics. This aligns with destructiveHint=true and enriches the agent's understanding of mutation semantics.

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 packs all five actions and their semantics into one dense paragraph without significant fluff. The 'FREE.' tag is slightly extraneous, and the long semicolon-separated sentence could be more scannable, but the content is appropriately sized for the tool's complexity.

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

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

For a tool with no output schema and a destructiveHint, the description covers the operational modes, limits, pause-versus-delete distinction, and the suggest workflow well enough for an agent to select and invoke it correctly. It does not describe response shapes or mention space_id, but required parameters are already documented in the schema.

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

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

Schema coverage is high at 75%, but the description adds the missing action-to-parameter mapping: add uses topics, update uses topic_id/keywords/search_context/is_active, and remove uses topic_id. It also reveals behavior not present in the schema, such as keywords being proposed when omitted, so it meaningfully supplements the parameter definitions.

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 being managed ('the inventory of aspects a brand talks about') and enumerates five concrete actions with distinct effects. This makes the tool's purpose unambiguous and distinguishes it from sibling tools that operate on campaigns, posts, or research.

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?

Each action is mapped to a specific use case: list reads, add appends, update edits or pauses, remove deletes, and suggest brainstorms new ideas. It even gives workflow guidance for suggest ('put them to the user, then add the keepers'). It does not explicitly state when not to use the tool or name sibling alternatives, 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 sparse annotations (readOnlyHint=false, destructiveHint=false), the description discloses significant behavioral consequences: making a private campaign public, turning on per-posted-reply billing (20 credits each), and demanding confirm:true only after user agreement. It also states that future drafts remain held, which is a partial-effect nuance not implied by the annotations or schema.

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

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

The description is information-dense yet every sentence carries unique value: purpose, cost, approval-step context, parameter selection, billing warning, and scope comparison. It is front-loaded with the core action and uses clear logical flow from when to use, how to pass parameters, and what to expect. No filler or repetition.

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

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

For a tool with one required, three optional parameters and no output schema, the description covers all essential aspects: preconditions, parameter selection, side effects, billing, confirmation, and scope distinction. An agent reading this description has enough information to call the tool correctly and avoid common mistakes. The absence of an output schema is not a gap here because the description's focus is on invocation and side effects.

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

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

With schema description coverage at 75%, the schema already explains most parameters. The description adds extra value by clarifying the either/or relationship between post_ids and all:true ('Pass the post_ids the user approved, or all:true.') and by reinforcing the conditional nature of confirm. It does not duplicate campaign_id directly, but the 'campaign created with post_visibility private' context effectively hints at its role. This is a meaningful boost above baseline.

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

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

The description opens with a specific verb-resource pair: 'Release chosen posts (and their reply drafts) to the community earn feed.' This clearly states the action, the object, and the exact destination. It further differentiates itself from update_campaign by explicitly contrasting scope: 'Unlike update_campaign's visibility flip, this touches only the posts you name and leaves future drafts held.'

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

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

The description gives explicit when-to-use context: 'This is the approval step for a campaign created with post_visibility 'private' (held mode).' It also explains when not to use it and names the alternative: 'Unlike update_campaign's visibility flip...' The confirm:true requirement is tied to the user agreement step, so an agent knows the exact precondition for invocation.

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 important non-obvious behaviors beyond the annotations: a cost of 5 credits per reply, refusal of already-claimed replies, and the need to confirm expenditure with the user. This exceeds what readOnlyHint and destructiveHint convey, though it could additionally clarify whether existing drafts are replaced.

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

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

Three sentences deliver the tool's purpose, side effects, cost, eligibility constraint, and user-confirmation requirement without padding. The main action is front-loaded, and every sentence adds operational value.

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

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

Given the absence of an output schema, the description still covers the essential behavior, cost, and refusal condition. The missing output format or return value is a minor gap because the operation's user-visible effect is clearly stated.

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 only 'post_ids' with a description; the description adds concrete meaning for 'edit_request' via examples and clarifies 'post_ids' come from 'get_posts'. 'campaign_id' remains implicit, but the overall semantics are sufficiently enriched.

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 ('redraft the replies'), the target resource ('replies of specific posts'), and the mechanism ('with an edit request'). It distinguishes itself from sibling tools like generate_posts, which is about creating posts, and review_posts, which is about reviewing rather than regenerating.

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 procedural guidance: obtain post IDs from get_posts and confirm the credit spend with the user before proceeding. It does not explicitly contrast with alternatives or state when not to use this tool, but the context is clear enough for an agent to decide.

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

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

The description clearly discloses the destructive behavior and dry-run protection, and adds important non-obvious details not visible in annotations: the 2-credit-per-post cost and the fact that dry runs are billed too. It also warns to confirm spend with the user, which is valuable behavioral 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?

Three sentences, front-loaded with the core action and dry-run behavior, followed by cost and workflow. Every sentence contributes necessary safety or sequencing information; no filler.

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

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

For a destructive, paid tool, the description is nearly complete: it covers dry-run, deletion, cost, billing, and safe sequencing. There is no output schema, so a slightly more explicit description of the verdict output format would make it fully complete, but this is enough for safe invocation.

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

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

The schema already describes dry_run, threshold, and critical billing behavior, so the description adds only marginal value for parameter meaning beyond that. It reinforces the dry-run workflow but does not clarify anterior-to-schema parameter values or add meaning for campaign_id.

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

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

The description states a specific verb ('score' and 'delete') and a clear resource ('every discovered post'). It also explains the dry_run case (kept), which makes it easy to tell apart from sibling tools like get_posts or generate_posts.

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

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

It gives an explicit safe workflow: start with dry_run:true, preview verdicts, then re-run with dry_run:false, and confirm spend with the user. It does not name alternatives for hand-off to sibling tools, so it stops short of explicit 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 convey readOnlyHint=false and destructiveHint=true; the description goes beyond by disclosing 'Any text change clears the old score' and the credit costs for revise/fix/humanize/review, plus that editing text is free. It clarifies that staging marks ready-to-publish but publishing happens elsewhere. No contradiction. Could be a 5, but some details like idempotency or failure effects are absent.

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 every sentence earns its place: action semantics, cost, side effects, user-decision boundary, and sibling routing. It is somewhat long and list-heavy, but appropriately so given seven actions. Front-loads the core purpose and defers the sibling comparison to the end.

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 high complexity (7 actions, 6 params, no output schema), the description covers what each action does, cost/credits, side effects on scores, user decision boundary, and when to use the sibling tool. The input schema adds parameter types/enums, and the description fills the behavioral gaps. Complete enough 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 covers 67% of parameter descriptions; the description enriches the action enum with plain-language meanings (e.g., 'revise rewrites it in the brand voice per a one-click preset', 'fix makes the surgical change the reviewer's notes asked for'). It also adds which parameters apply to which actions, bridging the 33% gap. Slightly more param-level detail would push to 5.

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

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

States a specific verb ('Act on one draft') and resource ('draft in the user's queue'). Distinguishes seven sub-actions, and explicitly points to sibling tool teach_content_voice for global reactions. Title adds context. Clear and 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?

Provides explicit when-to-use guidance: 'Stage and discard are the USER's decisions — act on their say-so, never on your own judgment.' Also explicitly names the alternative tool (teach_content_voice) and the condition for using it. This is model-tier 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 indicate readOnlyHint=false and destructiveHint=false, and the description aligns with that (no destructive claims). The description adds key behavioral details beyond annotations: caching for 7 days, the need for force:true to refresh, and the deferred side effect where expanded keywords are applied to the next generate_posts run. It also clarifies that other outputs are dormant until enabled. This is transparent about what the tool does and its downstream effects.

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 critical 'FREE pre-flight' label, then lists the outputs, then distinguishes automated vs. dormant results, and finally covers caching and force. While a bit long, every sentence contributes to correct invocation and expectation-setting. The structure effectively prioritizes the most important information.

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

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

For a research tool with no output schema, the description provides a thorough inventory of what the agent will receive (expanded keywords, phrases, influencer accounts, lists, competitors) and how to act on each category. It covers the caching mechanism, the free nature, and the interaction with other tools (generate_posts, update_campaign). This is sufficient for an agent to understand when to call the tool and what to do with the results, though it could mention prerequisites like campaign existence or error conditions.

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

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

The schema covers force with a description but leaves campaign_id undocumented (50% coverage). The tool description compensates by explicitly mentioning 'pass force:true to refresh' for force, and it implicitly defines campaign_id as the campaign being researched ('analyzes the campaign's keywords/topic'). While campaign_id is not explicitly described, its purpose is self-evident from the context, so the description adds meaningful semantic value beyond the schema.

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

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

The description states a specific action ('analyzes the campaign's keywords/topic') and lists concrete outputs (expanded keywords, high-intent phrases, influencer accounts, relevant X lists, competitors). It explicitly distinguishes itself as a 'FREE pre-flight' research step, differentiating it from get_research (which likely retrieves stored results) and generate_posts (which applies the results). The verb and resource are unambiguous.

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

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

Strong usage guidance: it tells the agent to use this tool 'before spending credits' and explains exactly which outputs are applied automatically (expanded keywords and exclusion terms via the next generate_posts run) versus which require enabling sources via update_campaign (free). It also addresses the caching scenario and how to force a refresh. This gives clear when-to-use and when-not-to-use 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 provide readOnlyHint=true, so the description carries a lower burden. It adds that the tool returns IDs, but does not disclose behavior like partial matching, pagination, or case sensitivity. The description is consistent with annotations and adds some workflow context.

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

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

Two sentences, zero waste. The first sentence states the core action and output. The second sentence provides context and a workflow hint. Every sentence is essential.

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 search tool with no output schema, the description is fairly complete. It explains the purpose, output, and why the tool is needed. It could be more explicit about matching behavior, but the combination with annotations and schema makes it adequate.

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

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

Schema description coverage is 100% – both parameters have clear descriptions. The tool description only mentions 'by name' which maps to the query parameter, adding no new meaning beyond the schema. Baseline 3 is appropriate.

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

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

The description states 'Search the user's ProductClank products by name and return their IDs' – a specific verb+resource with clear output. It distinguishes from siblings like create_product and list_content_spaces by focusing on search/lookup for campaign resolution.

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 ties this tool to campaign creation/boosting workflow: 'A product_id is required to create or boost a campaign — use this to resolve it, then confirm the match with the user.' It provides clear context for when to use, though it does not explicitly mention when not to use or name alternatives.

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

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

The description highlights critical unattended behavior: enabling is free but authorizes later hourly job spend at 12 credits per post discovered. It explicitly warns that costs happen outside the call and without user presence, explains the safety of the off path, and gives concrete operational limits (4 runs/day, 20 posts/run, 600 credits/day) — all material that annotations 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?

Although fairly long, every section earns its place: the warning is front-loaded, steps are numbered, and exclusions/limits are grouped logically. The text is dense with high-value guidance and avoids unrelated filler, so its length is justified by the safety-critical nature.

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 invocation flow, expected first-call outputs, user-confirmation requirements, safety thresholds, cost implications, and how to read the current schedule. Given there is no output schema, the description provides enough detail for full correct invocation without leaving a necessary gap.

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

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

The description goes far beyond the input schema by explaining the confirmed flag's intentional flow and the meaning of an omitted confirmed flag. It also connects posts_per_run and frequency_per_day to real costs and spending limits, and clarifies that enabled:false requires no confirmation, adding behavioral context the schema cannot express.

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 precise, action-oriented statement: 'Turn standing discovery on or off for a campaign.' It clearly names the resource and the two possible operations, and it is fully distinguishable from sibling tools like get_campaign by referencing the read operation at the end.

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 an explicit, step-by-step usage protocol: call with enabled:true and no confirmed flag first, show the user the projected costs, get explicit agreement, then call again with confirmed:true. It also clearly states when confirmation is never allowed and when enabled:false is safe, giving the agent clear decision rules.

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

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

The description adds meaningful behavioral detail beyond the annotations: structured fields are FREE, brand_doc costs 5 credits, topics are appended with a 12-per-call cap, keywords are auto-proposed when omitted, and nothing is published. These are non-obvious side effects and constraints that an agent needs to know before invoking 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 dense but every sentence carries useful information, from billing to workflow to side effects. It is appropriately sized for an 11-parameter tool, though the long prose paragraph could be better structured with bullets or explicit sequencing. It is front-loaded with purpose and cost, which helps an agent scan it 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 tool of this complexity, the description covers the workflow, required inputs, billing, topic behavior, and the fact that nothing is published. With no output schema, a brief note about what the call returns or how to verify success would strengthen it, but the provided description is already sufficient for an agent to invoke it correctly in most 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?

Even though schema description coverage is 100%, the description adds crucial semantic guidance: first-time setup requires at least voice and platforms, space_id/new_space are mutually exclusive routes, topics are appended, and brand_doc should only be passed when the user provides a written template. This materially improves parameter understanding beyond the raw schema.

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

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

The description opens with a specific action: 'Turn the content engine on for a brand from an onboarding conversation, or update its settings later.' This clearly identifies the resource (a brand's content space) and the operation (set up or update), and it does not merely restate the tool name. The title and description together distinguish it from sibling tools like generate_posts or manage_content_topics.

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

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

The description gives a concrete workflow: collect answers first via the setup prompt, read them back for confirmation, then call once. It also specifies when to use space_id vs new_space and when to pass brand_doc. However, it does not explicitly name alternatives or state when not to use this tool versus a sibling, 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?

The description adds substantial behavioral detail beyond the annotations: submissions land as PENDING, review and reward occur on approval, X URLs must be author-verified, duplicate URLs are rejected, and media must already be publicly hosted. This level of transparency is strong and non-redundant.

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 organized. It front-loads the core action and proof options, then adds constraints and post-submission behavior. Each sentence. The detail is meaningful, not filler.

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

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

For a write operation with no output schema, this description covers the essential gaps: expected input formats, URL restrictions, verification rules, submission state, and how to check status afterward. It gives an agent enough to call the tool correctly and explain to users what happens 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?

Schema description coverage is high at 75%, but the description enriches the parameters further—it explains that any one proof is enough, clarifies media URL requirements, mentions the 500-character limit for descriptions, and states author verification for X posts. This is useful beyond what the schema already captures.

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-resource pair: 'Submit the user's work for a campaign' and enumerates three acceptable proof types. It is specific and actionable, but it doesn't explicitly distinguish itself from the similarly named sibling tool 'submit_participation', so it loses one point for sibling differentiation.

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

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

The description gives clear context: the three proof channels, the hosting prerequisite, and the explicit routing to get_my_submissions afterward. It doesn't fully state when-not to use this tool or how it compares to submit_participation, but it gives enough usage context to select the right behavior.

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

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

Annotations declare readOnlyHint false, openWorldHint true, and destructiveHint false. The description significantly expands on these by detailing that it awards points and credits, adds strikes on rejection (blocking at 3), requires linked handles, and performs verification. It also explains the quote post URL requirement and failure behavior when a handle is missing, providing rich 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 longer than average but each sentence adds necessary detail—purpose, platform list, quote exception, verification, handle requirement, and consequences. It front-loads the core action and then expands logically, though a slight trim could improve focus without losing essential caveats.

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

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

For a complex write operation with no output schema, the description covers prerequisites (linked handle), platform-specific behaviors, failure modes, and post-submission effects (points, strikes). It leaves no critical operational detail unexplained, making it fully adequate for an agent to execute correctly.

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

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

Schema coverage is 100%, so parameters are documented, but the description adds crucial semantics: reply_id comes from find_opportunities, and reply_url for quote posts must be the user's own quote post URL, not the original. This clarifies ambiguous edge cases that the schema alone doesn't capture, significantly improving correct invocation.

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 submits a URL for a claimed opportunity, referencing reply_id from find_opportunities. It specifies supported platforms and the quote post special case, making its function distinct from siblings like submit_campaign_work without needing further disambiguation.

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 implies usage after find_opportunities and details platform-specific behavior (X quote posts vs. replies). It does not explicitly state when not to use it or name alternatives, but the context is clear enough for an agent to decide when this tool is appropriate.

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

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

Annotations already declare readOnlyHint=true, so the description need not re-disclose that. It adds valuable context: FREE, no credits charged, returns draft and affordability (1000 credits), and the required follow-up workflow. 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 bit long but every sentence serves a purpose: scoping, cost, output, workflow, and prerequisites. It is front-loaded with the 'preview, free, nothing created' key facts. Slightly dense but well-structured.

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

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

Given the tool's complexity (7 params, no output schema, safety-critical workflow), the description covers everything an agent needs: what it returns, the credit threshold, the explicit-consent and next-step requirement, and the prerequisite product_id. 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 covers all 7 parameters at 100%, so baseline is 3. The description adds meaning beyond the schema by telling how to fill campaign_message ('from what you know about the product') and that product_id must come from search_products. This extra guidance raises it above baseline.

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

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

Clearly states it previews a campaign before launch, returns a draft and affordability check, and explicitly says it does not launch. Distinguished from sibling create_content_campaign by the 'BEFORE launching' and 'never launch' emphasis.

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 call create_content_campaign after getting an explicit yes, and never launch off the preview alone. Also specifies that product_id must come from search_products and how to write campaign_message.

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

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

Annotations only declare readOnly=false and destructive=false, but the description adds substantive behavior: durable rule creation, default immediate application, pending behavior with apply:false, the 1-credit cost, and the required follow-up ('Tell the user in one line what was learned'). This goes well beyond the annotation 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 well-structured and front-loaded with the core purpose, followed by cost, usage contrast, parameter guidance, and response instruction. Every sentence contributes, though the example list could be slightly tighter.

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 covers purpose, usage, parameter semantics, default behavior, and the expected user-facing response. It is complete enough for correct invocation, with only minor non-essential details (e.g., exact response shape, space_id clarification) omitted.

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

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

Schema coverage is 75% (space_id undocumented). The description adds rationale for draft_id ('so the rule is grounded in an example'), clarifies apply:false with 'pending in the web Settings', and gives concrete examples for feedback. This adds real meaning beyond the schema entries.

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

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

States a specific verb ('Teach') with a clear resource ('the engine', i.e., the brand's voice KB) and explicit examples of what counts as feedback. It also distinguishes itself from sibling revise_content_draft, so an agent can tell them apart immediately.

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

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

Gives explicit when-to-use ('when feedback should STICK') and when-not-to-use ('use revise_content_draft when it is about one draft only'), plus additional parameter-level guidance for draft_id and apply:false. No inference is required.

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

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

Annotations only provide readOnlyHint=false and destructiveHint=false, which offer minimal safety signals. The description compensates with rich behavioral detail: keyword merging, sources staying dormant until enabled, is_active pausing all discovery and billing, visibility flipping to public releasing drafts (with a warning to confirm with the user), and the platform lock. It also explains that changes apply to the next generate_posts run and existing posts are not re-scored. This exceeds what annotations convey.

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

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

The description is long but every sentence carries operational weight. It front-loads the core purpose and billing note, then walks through key parameters in a logical order, each with a concrete behavior or consequence. There's no redundant or filler language; it's dense but efficient. While it could be slightly trimmed, the length is justified by the complexity of the tool.

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 13 parameters, only one required, no output schema, and minimal annotations, the description shoulders a heavy burden. It covers side effects (visibility release), constraints (platform lock, confirm requirement), defaults (relevance_threshold starts at 5), semantics (merge vs. replace), and timing (next run, no re-scoring). It even names sibling tools like get_campaign for reading current lists. An agent has everything needed to call correctly without external knowledge.

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

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

Schema description coverage is 92%, so the baseline is 3. The description adds substantial value beyond the schema: it explains merge semantics for add_keywords, the dormant nature of sources until enabled, the meaning of relevance_threshold with a default, the replace-not-append behavior of target_subreddits/channels, and the platform lock. These are operational details not captured in the schema, so the description meaningfully enhances parameter understanding, though not every nuance (e.g., confirm is well-covered in schema) 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 opens with 'Adjust a live campaign without recreating it,' a specific verb and resource that clearly distinguishes it from create_campaign and other siblings. The title 'Tune a running campaign' reinforces the exact scope. An agent immediately knows this is for modifying an existing campaign, not for creation or other operations.

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

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

The description explicitly states when to use this tool (adjusting a live campaign) and provides a clear alternative for a locked platform: 'platform itself can only change while the campaign has discovered nothing — after that it is fixed, and a second campaign is the answer.' It also notes when not to use it via the platform constraint and gives context about billing ('Free — nothing here spends credits, though the next generate_posts run bills as usual'). This gives an agent a complete decision framework.

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 drafts are scored against the brand's voice, queued in 'All Content' for approval, and never auto-published. It also states the candidate limit of 25 per call. This substantially enriches the agent's understanding of what happens after invocation.

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 more expansive than the minimal ideal, but nearly every sentence earns its place: purpose, prerequisite, scoring feedback loop, platform rule, queue outcome, limit, and exclusion of community campaigns. It is front-loaded with the core purpose and keeps the most important constraints early. Slight redundancy around the queue and scoring costs a point.

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-oriented tool with no output schema, the description covers prerequisites, parameter constraints, side effects, approval flow, and the intended alternative. It tells the agent where results will appear (get_content_queue) and what will not happen (no auto-publishing). Nothing critical for correctly selecting and invoking the tool is missing.

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

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

Schema coverage is 100%, so the baseline is 3. The description adds meaningful semantic detail beyond the schema, especially the platform constraint: 'platform must be one of the space's platforms (omit it to use the first).' It also reinforces the 25-candidate limit and the default template behavior, which helps correct invocation.

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: 'Draft one or more posts into a ProductClank content space.' It then differentiates this tool from create_content_campaign, clarifying that this writes into the user's own content pipeline rather than a community campaign. This is a clear, non-tautological purpose statement that an agent can act on.

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

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

The description gives explicit when-to-use guidance: 'Call get_content_workspace FIRST', use the space's platforms, and omit platform to use the first. It also names the alternative for community campaigns: 'use create_content_campaign for that.' The conditions are concrete and leave little to inference.

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