FavCRM

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

The description discloses that the tool sends a 6-digit verification code to the invited email, which is a key side effect. Annotations already indicate non-idempotent (idempotentHint=false) and mutation (readOnlyHint=false), so the description adds appropriate 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?

Two sentences, no wasted words. Front-loaded with the step context and action, followed by the next step. Very efficient.

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

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

The description clearly explains the tool's role in a two-step process. Since an output schema exists, it is acceptable that return values are not detailed. Some minor gaps exist (e.g., token source), but overall 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%, and the parameter 'token' is well-documented in the schema. The tool description does not add further parameter details; it only mentions 'invite token' in context. 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 explicitly states it is 'Step 1 of agentic team invite acceptance' and specifies the action: validates token and sends verification code. This clearly distinguishes it from the sibling tool 'accept_team_invite_verify' which is step 2.

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 positions itself as the first step and instructs to call 'accept_team_invite_verify' next. However, it does not mention where to obtain the invite token or prerequisites, relying on the schema's parameter description for that detail.

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?

Discloses three main actions (verify, join, return) and confirms write operation (readOnlyHint=false). Does not discuss error states or idempotency, but sufficient for basic behavior awareness.

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

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

Single sentence front-loaded with purpose. Every word earns its place, no fluff.

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

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

Covers main actions but omits that a new user can be created via the optional 'name' field. Given the output schema exists, returns are somewhat covered, but the optional user creation 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?

All parameters have schema descriptions (100% coverage). The description adds context that the token comes from the invite creation step, which is helpful 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?

Clearly states it's step 2 of invite acceptance, with specific actions: verify code, join user, return API key. Distinguishes from sibling 'accept_team_invite_request' as the next 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?

Explicitly says 'Step 2' and mentions the token source (create_team_member_invite or invite link), guiding when to use. Could be improved by noting not to use before step 1.

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

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

The description adds behavioral context beyond annotations: it confirms the tool stores a document, clarifies that embedding and retrieval are handled elsewhere, and implies an immediate write operation. No contradiction with annotations.

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

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

Three concise, front-loaded sentences with no wasted words. Each sentence serves a distinct purpose: action, use cases, and storage detail.

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

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

For a simple add tool with fully described schema, the description is adequate. It explains storage and retrieval context, though it could mention duplicate handling or overwrite behavior.

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

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

Schema coverage is 100% with basic descriptions, but the description adds value by explaining the type of content expected (policies, FAQs, etc.) and that 'name' is a friendly title, which enriches the parameter semantics.

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

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

The description clearly states the tool adds a free-form text document to the knowledge base, lists specific use cases (policies, FAQs, etc.), and distinguishes it from siblings like query, delete, and scrape 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 provides clear examples of when to use the tool (pasted policies, FAQs, etc.) but does not explicitly mention when not to use it or suggest alternatives like scrape_knowledge_url for web 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 this is not read-only (readOnlyHint=false) and not destructive (destructiveHint=false). The description adds behavioral context: blocks are appended to the end, and each block must follow a specific structure with required fields id, version, type, data along with a list of supported types. It does not cover side effects, permissions, or error conditions, but the annotations provide the safety profile. This is a reasonable addition beyond the annotations.

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

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

The description is extremely concise at two sentences, with the key action and requirement front-loaded. Every word serves a purpose: the tool's action, target, block format, and supported types. No fluff 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?

Given the tool's moderate complexity (2 parameters, detailed nested schema, and an output schema), the description covers the core functionality well. It explains the block requirement and lists all 17 block types. It does not discuss return value (output schema exists), error handling, or edge cases, but for an append tool this is sufficient. The presence of an output schema alleviates the need to describe return 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 coverage is 100%, meaning the schema already fully documents the two parameters (postId and blocks). The description summarizes the block structure and lists types, which adds some convenience but does not clarify parameter semantics beyond the schema. For instance, it doesn't explain how to construct a block's 'data' for each type (though the schema's oneOf provides that). So the description adds marginal value, earning a baseline 3.

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

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

The description clearly states the verb 'Append' and the resource 'blocks to a post'. It specifies that blocks are added to the 'end of a post', which is precise. Sibling tools like 'remove_post_block', 'reorder_post_blocks', and 'replace_post_block' have distinct purposes, so this tool is well-differentiated.

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

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

The description implies when to use this tool (to add blocks at the end of a post) but does not explicitly mention when not to use it or provide alternatives. For example, it doesn't contrast with 'replace_post_block' or 'insert' (if such existed). The usage context is clear but lacks explicit exclusions or guidance on adjacent tools.

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

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

Annotations already indicate destructiveHint=true and idempotentHint=true. The description adds that the survey is removed from active lists, but does not disclose details about recoverability, permissions, or impact on existing invitations/responses. With annotations covering the main behavioral traits, the description adds moderate value.

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

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

Single sentence, front-loaded with the action, no unnecessary words. Achieves maximum conciseness while still conveying purpose and effect.

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

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

The description is sufficient for a simple archive action given annotations and output schema. However, it lacks context about reversibility (e.g., whether archived surveys can be restored) and side effects on survey data or active workflows. Sibling tools include restore_* for other entities, but no explicit mention here.

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

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

Schema coverage is 100% for the single parameter surveyId, with a clear description in the schema. The tool description does not add additional semantics beyond what the schema provides. Baseline 3 is appropriate.

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

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

Description uses specific verb 'Archive' and resource 'survey', and states the effect 'remove it from active survey lists'. This clearly distinguishes it from sibling tools like create_survey, get_survey, list_surveys, and update_survey.

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

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

No explicit guidance on when to use this tool versus alternatives, such as update_survey or delete_survey. The description implies usage when archiving is intended, but does not provide exclusions or mention prerequisites.

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

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

Annotations indicate this is a non-readonly, non-destructive mutation. The description's verb 'assign' aligns with a write operation, but it does not disclose potential side effects (e.g., replacing existing assignments) or permission requirements.

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

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

Two concise sentences: first states purpose, second provides a crucial parameter hint. No unnecessary words, front-loaded.

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

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

For a simple assignment tool with an output schema and low parameter count, the description covers the essential: what it does and how to supply the userId. Could mention potential overwrite behavior, but not critical.

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

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

With 100% schema coverage, the description adds value by clarifying that userId should come from 'list_staff.userId', providing a meaningful cross-reference. ServiceId is less elaborated, but schema description suffices.

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

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

Description clearly states the action ('Assign a staff member to a booking service') and identifies the resource. It provides a specific hint on obtaining the userId from list_staff, but does not explicitly differentiate from sibling tools like 'link_resource_to_service'.

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

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

The description implies usage by instructing to pass the userId from list_staff, suggesting a prerequisite call. However, it does not provide explicit guidance on when to use this tool versus alternatives or what to avoid.

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 that it verifies the job belongs to the company and succeeded, and does not charge credits (charged at submit). This adds behavioral context beyond annotations. However, it doesn't mention potential side effects like overwriting an existing cover, though annotations already show destructiveHint=false.

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

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

The description is very concise: three sentences that front-load the purpose, then usage context, then verification and credit info. No wasted words.

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

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

Given the full schema coverage, output schema exists, and annotations provide some safety hints, the description is complete. It covers purpose, usage scenarios, verification, and credit behavior, making it sufficient for an agent to decide when and how to invoke.

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

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

Schema coverage is 100%, so baseline is 3. The description adds meaning by explaining the overall scenario (reusing a job), which helps interpret parameters like jobId, pollIfRunning, etc. It provides enough context to understand parameter roles beyond the schema descriptions.

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

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

The description clearly states the tool attaches a previously generated ai-media job's output as the post's featuredImage. It specifies the verb 'attach' and resource 'post cover', and distinguishes from siblings like generate_post_cover and upload_post_cover_from_url by indicating reuse scenario.

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

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

Explicitly says when to use: when generate_post_cover timed out (job kept running) or when reusing the same generation across multiple posts. It provides clear context for when this tool is appropriate versus alternatives.

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

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

Annotations already declare readOnlyHint=false, so the tool is clearly a write operation. The description adds the context of segmenting members but does not disclose details like whether attachments overwrite existing tags or cause side effects. With annotations present, the description provides adequate but not rich behavioral context.

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

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

The description is a single, front-loaded sentence that communicates the primary action, target, and a use case. Every word earns its place with no redundancy.

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

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

Given the simple parameter structure, the presence of an output schema, and annotations covering behavioral traits, the description sufficiently explains the tool's purpose and context. It could mention the maximum number of account IDs (100) explicitly, but the schema already documents that.

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 describes both parameters (tagId as string, accountIds as array with max 100) with 100% coverage. The description does not add additional meaning or constraints beyond what the schema provides, so baseline 3 is appropriate.

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

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

The description clearly states the action ('Attach') and the resource ('tags to a member/account'), and it provides a specific use case ('segmenting members after filtering'). This distinguishes it from sibling tools like 'detach_tags' or 'create_tag'.

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 includes a context hint ('Useful for segmenting members after filtering'), which implies when to use the tool. However, it does not explicitly state when not to use it or compare it to alternatives like 'detach_tags'.

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 useful behavioral context beyond the destructiveHint annotation by stating that a durable refund receipt is created and that the refund method follows merchant settings unless overridden. It does not describe all consequences of cancellation, but the annotation covers the destructive 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 two sentences, front-loaded with the main action and then a concise detail about refund behavior. Every word contributes value with no redundancy.

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

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

The description covers the core action and the refund behavior, and an output schema exists to explain return values. It does not elaborate on idempotency or retry semantics, but the idempotencyKey parameter description in the schema covers that. Overall adequate for a destructive mutation tool.

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

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

Schema description coverage is 100%, providing baseline 3. The description adds extra semantics for refundMethod by explaining the default merchant setting, which exceeds the baseline. Other parameters are adequately described in the schema.

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

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

The description clearly states the tool cancels a booking and creates a durable refund receipt, using a specific verb and resource. It distinguishes itself from related booking tools like confirm_booking or complete_booking by focusing on cancellation and refund receipt creation.

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

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

The description implies the tool is used to cancel a booking, but it does not provide explicit guidance on when to use this tool versus alternatives, nor any exclusions or prerequisites. It mentions refundMethod override, but no context on when to choose manual vs account_credit.

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 set destructiveHint to true. The description adds valuable detail: explains what destruction means in this context (turns off auto-renew, prevents further billing, existing paid periods remain valid). This goes beyond the annotation and fully discloses the behavioral implications.

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

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

The description is extremely concise, consisting of three short sentences. It front-loads the key action and each sentence provides unique value: action, destructive nature, and the effect on billing and existing periods. No waste.

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

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

For a simple, one-parameter destructive operation with an existing output schema and clear annotations, the description covers essential behavioral aspects. It lacks mention of prerequisites (e.g., having an active subscription) but is otherwise sufficient.

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

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

Schema coverage is 100% with the subscriptionId parameter already described as 'Subscription ID'. The description adds no additional parameter-level detail beyond what the schema provides. Baseline score of 3 is appropriate.

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

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

The description clearly states the tool cancels a subscription and specifies that it turns off auto-renew, preventing future billing. It implicitly distinguishes from sibling tools like pause_subscription by labeling it 'Destructive', indicating permanent action.

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

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

The description provides clear context for use (final cancellation of auto-renew and billing) but does not explicitly mention when not to use it or name alternative tools such as pause_subscription or resume_subscription. The destructive label helps, but explicit guidance would improve.

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

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

Annotations already indicate read-only, idempotent, non-destructive behavior. The description adds valuable context about the specific checks performed (scopes, modules, subscription, quota), complementing the annotations effectively.

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

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

The description is a single, well-structured sentence that conveys the essential information without any extraneous wording.

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

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

Given the tool's simple preflight nature, existing annotations, and an output schema, the description provides sufficient context. It covers the purpose, key checks, and parameter expectations adequately.

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

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

Schema description coverage is 100%, so the schema already documents all parameters. The description restates that toolName, quotaCode, or moduleCode should be provided, adding no new 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 explicitly states the tool's purpose as a preflight check for operations, listing the specific checks (token scopes, enabled modules, subscription state, quota). This clearly distinguishes it from sibling tools that perform actual 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 implies when to use this tool (before performing an operation to check permissibility) but does not explicitly mention alternatives or when not to use it. The context is clear but could be improved with direct 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?

Discloses key behavioral traits: duplication, default name change, DRAFT status creation. Annotations (readOnlyHint: false, destructiveHint: false) are consistent, and description adds valuable 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?

Single, focused sentence conveying core behavior without redundancy. Front-loads action ('Duplicate an existing record') and follows with specifics.

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

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

Covers essential behavior; output schema exists so return values need not be described. Could mention error cases (e.g., entity not found) but not necessary for basic usage.

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

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

Schema coverage is 100% with clear parameter descriptions. Description does not add new semantic meaning beyond the schema, but confirms default name behavior for the 'name' parameter.

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

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

Clearly states it duplicates an existing record, lists supported entity types, and describes key transformation (DRAFT status, '(Copy)' appended). Unambiguous and distinct from create/update 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?

Implies usage when needing a copy of an existing record, implicitly contrasting with create_* (new from scratch) and update_* (modify existing). No explicit when-not-to-use, but context is clear.

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

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

Description discloses the side effects: accounts are created/updated and points, stamps, and credit deltas are applied. Annotations indicate it is not read-only and not destructive, which aligns. Additional detail on idempotency or failure behavior would enhance transparency.

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

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

The description is concise: two sentences that front-load the purpose and then give the key usage instruction. No unnecessary words.

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

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

The description covers the tool's purpose, side effects, and parameter relationship to preview. Since an output schema exists, return values need not be described. Minor missing details like constraints (max rows) are present 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?

The description adds value by specifying that the rows and sessionId should be exactly those returned by preview_customer_import, which is not apparent from the schema alone. With 50% schema coverage, this guidance is crucial.

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 'commit' and the resource 'customer import', and specifies it creates/updates accounts and applies points/stamps/credit deltas. It also explicitly names the sibling tool 'preview_customer_import' to distinguish the two steps.

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?

Description instructs to use the same rows and sessionId returned by preview_customer_import, establishing clear context for when to use this tool. It implicitly excludes using it without a preview, but does not explicitly state alternatives or when not to use.

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

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

The description adds the side effect of commission calculation beyond what annotations provide (annotations show destructiveHint=false and readOnlyHint=false, but this is a mutation). However, it does not disclose potential irreversibility or other behavioral traits like whether it changes booking status permanently.

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

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

The description is concise with two sentences, front-loading the main action and adding the key side effect. No redundant information.

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

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

Given the tool has a single parameter, an output schema (not shown), and annotations, the description adequately covers the purpose and side effect. However, it could mention permission requirements or confirm if the action is reversible for completeness.

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

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

The only parameter bookingId is fully described in the schema ('The booking ID to complete'). The description does not add additional meaning or format details beyond the schema. With 100% schema coverage, baseline of 3 is appropriate.

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

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

The description clearly states the verb 'mark as completed' and the resource 'booking'. It also mentions the side effect of triggering commission calculation, which distinguishes it from sibling tools like cancel_booking or confirm_booking.

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

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

The description implies usage when a booking is finished and commission should be triggered, but it does not explicitly state when to use this tool over alternatives like cancel_booking or confirm_booking. No exclusions or alternative tools are mentioned.

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 (mutation) and destructiveHint=false, but the description adds no behavioral context beyond that. For example, it doesn't explain side effects (e.g., status change, notifications) or whether the action is reversible. The description relies entirely on annotations.

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

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

Single sentence with no unnecessary words. Directly conveys the purpose. Excellent conciseness.

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

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

An output schema exists but is not shown; the description does not explain success/error behavior or state changes. While minimal, it provides enough for a straightforward mutation. Could benefit from clarifying what 'confirm' entails (e.g., booking status becomes 'confirmed').

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 all parameters (100%), with a clear description for 'bookingId'. The tool description adds no additional insight beyond what's already in the schema. Baseline score of 3 is appropriate.

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

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

The description 'Confirm a pending booking' clearly states the action (confirm) and resource (booking). It distinguishes from siblings like 'cancel_booking' and 'complete_booking', though not explicitly contrasting. 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?

No guidance on when to use this tool versus alternatives. Does not specify prerequisites (e.g., booking must be pending) or conditions under which confirmation is appropriate. Lacks context to guide agent decision-making.

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 does not disclose what happens to the original lead account after conversion (e.g., deletion, archiving) or any side effects. The annotations (readOnlyHint=false, destructiveHint=false) provide minimal info, so the description carries a heavy burden which it fails to meet.

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

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

The description is a single, front-loaded sentence that efficiently conveys the core purpose and optional behavior without unnecessary 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 has 7 parameters and an output schema, the description is brief. It covers the main purpose and optional deal creation but omits prerequisites, error conditions, or return value details. Adequate but not comprehensive.

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 all parameters described in the schema. The description adds marginal value by mentioning the optional deal creation and lifecycle change, but does not significantly enhance understanding 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 action 'Convert a lead account to an active customer' with the optional deal creation, distinguishing it from related tools like create_deal or create_account.

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

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

The description provides context by mentioning the optional deal creation, but does not explicitly state when to use this tool versus alternatives. It implies a conversion scenario but lacks 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?

The description indicates this is a mutation ('Create'), consistent with annotations (readOnlyHint: false). It adds context about optional enrollment and primary contact creation, but does not detail side effects like failure handling or contact creation mechanics.

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

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

Two sentences, no redundancy. The first sentence states the main action, and the second provides guidance on when to use the sibling tool. Efficient and 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?

Though output schema exists, the description does not explain the return value or what constitutes a 'primary contact'. It omits context about prerequisites (e.g., company context) and interaction between parameters like enrollMembership and tierId. Adequate but not fully comprehensive.

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

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

Schema description coverage is 100%, so the schema already documents all parameters. The description adds no additional parameter-specific details beyond what the schema provides.

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

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

The description clearly states the verb 'Create', the resource 'CRM account/customer', and specifies that a primary contact is also created. It distinguishes from the sibling tool 'enrol_membership' by noting when to use that tool instead.

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 when to use this tool versus enrol_membership, indicating that enrollment can be done optionally now or later via the sibling tool. It implicitly advises using this tool when the account does not yet exist.

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 a non-read-only, non-destructive write operation. The description confirms creation but does not add details like authorization needs, side effects, or rate limits. With annotations already covering the basic behavioral profile, the description adds the prerequisite step but little else.

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

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

Two sentences, no wasted words. First sentence states purpose, second provides critical usage guidance. Efficient and 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 output schema exists (not shown, but indicated), the description doesn't need to cover return values. It covers purpose, prerequisite, and key parameters. With 8 parameters and moderate complexity, the description is adequate but could mention that the booking is created immediately or if any confirmation is needed.

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

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

The input schema has 100% description coverage for all 8 parameters, so the schema already defines them well. The description mentions 'service, member, date, and time' which maps to key parameters but adds no new semantic meaning beyond the schema.

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

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

The description clearly states 'Create a new booking for a member,' specifying the verb and resource. It distinguishes from sibling create tools by adding the prerequisite step 'Use get_available_slots first,' making it clear this is specifically for bookings.

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 the agent to first use get_available_slots to find valid times, then create the booking with the required parameters. This provides clear when-to-use and how-to-use guidance, differentiating it from other 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 provide no destructive or idempotent hints, but the description adds crucial behavioral context: the broadcast is a draft and requires admin action to send. This goes beyond what annotations convey.

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

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

The description is concise with two sentences, front-loading the key purpose and lifecycle detail. No unnecessary 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 output schema existence, the description covers the purpose, behavior, and lifecycle adequately. It does not explain return values, but that is handled by the schema.

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

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

Schema description coverage is 100%, so baseline is 3. The description does not add significant meaning beyond the schema; it only mentions channel options which are already defined in the schema.

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

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

The description clearly states it creates a DRAFT WhatsApp or SMS broadcast campaign, using specific verbs and resources. It distinguishes itself from other create tools by specifying the draft-only nature and the channel options.

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 the broadcast is NOT sent and requires admin review, guiding the agent on when to use this tool (to create drafts). However, it does not mention alternatives for immediate sending if such exist.

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, so description carries burden. It adds that campaigns start as DRAFT and that 'list' is normalized to 'individual', and provides email config specifics. No contradictions. Good 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?

Extremely concise: two sentences, no filler. First sentence states core purpose and scope; second gives key usage tips. 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 output schema exists and schema coverage is 100%, the description adequately covers creation context (DRAFT default, email config, alias). Could mention scheduling or company scoping, but overall sufficient for a creation tool with rich schema.

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

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

Schema coverage is 100%, so baseline is 3. The description adds marginal value by reiterating email config details and the recipientSource alias, but most of that is already in schema. No additional meaning beyond schema for other parameters.

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

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

The description specifies the action (create) and resource (marketing campaign) and adds context (channels: email, SMS, WhatsApp) and initial state (DRAFT). It is clear but does not distinguish from sibling tools like create_broadcast or create_promotion, which might overlap.

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

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

The description provides some usage hints (e.g., email channelConfig fields, recipientSource alias) but no explicit guidance on when to use this tool versus alternatives. It lacks when-not or comparison to siblings, leaving the agent to infer usage context.

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

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

Only states the action without disclosing side effects, permissions needed, or return behavior. Annotations indicate non-read-only and non-destructive, but description adds no behavioral context beyond the basic action.

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

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

Two sentences, front-loaded with verb, no wasted words. Efficiently conveys purpose and a key usage note.

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?

Adequate for a simple creation tool with full schema and output schema. However, it lacks differentiation from sibling category tools and does not address error scenarios or required permissions, leaving some gaps.

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

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

Schema covers all 4 parameters fully. Description adds minimal value beyond schema for the name parameter (sub-category naming). Baseline of 3 is appropriate given high schema coverage.

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

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

Clearly states it creates a CMS post category with examples. The name and description distinguish it from sibling tools like create_product_category and create_service_category, even without explicit 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?

Provides one guideline about sub-category naming (namespaced names) but does not explicitly compare to other category creation tools or state when to use this vs alternatives. Usage context is implied but not fully articulated.

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 write operation (readOnlyHint=false) and non-destructive (destructiveHint=false). The description adds that the contact is created on an existing account, implying validation but no further behavioral details like side effects or permissions.

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

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

One sentence of 9 words, very concise. It front-loads the key info but could add a bit more context without becoming verbose.

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

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

The description is minimal but sufficient given the presence of a complete input schema and output schema. However, it omits mention of the return value (expected since output schema exists) and does not clarify required fields beyond 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 100%, so the description adds no extra meaning beyond the schema's per-parameter descriptions. The overall context aligns with the schema but does not enhance understanding.

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

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

The description clearly states the verb 'Create' and the resource 'contact on an existing CRM account', distinguishing it from other contact operations like update or delete. It uniquely identifies the tool's purpose among 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?

No explicit guidance on when to use this tool versus alternatives (e.g., update_contact, import). The description implies an existing account but does not specify prerequisites or scenarios where other tools are better suited.

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

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

Annotations already declare readOnlyHint=false and destructiveHint=false. The description adds no new behavioral context (e.g., idempotency, permissions, side effects) beyond the creation action. It does not contradict annotations.

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

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

Two sentences, front-loaded with the primary action, no superfluous words. Efficient and easy to parse.

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

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

With 7 parameters, 4 required, a rich schema, and output schema present, the description is adequate. It could mention uniqueness constraints on fieldName, but overall complete for a creation tool with good schema coverage.

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

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

Schema coverage is 100% with parameter descriptions. The description adds minimal value by linking options to select/multiselect, which is already in the schema description. No new semantics for other parameters.

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

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

The description clearly states the tool creates a custom field definition for CRM entities, distinguishing it from post type field creation by specifying the CRM context. The verb 'create' and resource 'custom field' are 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 mentions using options for select/multiselect fields, providing some usage guidance, but does not explicitly state when to use this tool versus alternatives like create_post_type_field or update_custom_field. No exclusions or context for not using it.

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

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

The description's 'Create' action aligns with annotations (readOnlyHint=false, not idempotent). However, it does not add behavioral context beyond what annotations already provide, such as permissions or side 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 a single, front-loaded sentence with no wasted words. It efficiently communicates the core function.

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

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

Given the tool has an output schema, the description does not need to explain return values. It covers the essential purpose and key optional links. It is adequate, though it could mention the default pipeline or required permission.

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

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

Schema coverage is 100% with parameter descriptions. The description adds value by hinting at the optional linking (accountId, contactId) but does not significantly enhance understanding 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 action 'Create', the resource 'CRM sales pipeline deal', and the optional linking to account and contact. This distinguishes it from sibling tools like update_deal, get_deal, and list_deals.

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

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

The description implies use when creating a new deal but does not explicitly state when not to use it or mention alternatives (e.g., update_deal for existing deals). The context is clear but lacks explicit 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 value beyond annotations by clarifying that despite being a create operation (readOnlyHint=false), it only creates a draft suggestion and does not send anything. It also describes where it appears (inline in composer). However, it does not disclose permissions, rate limits, or side effects on conversation state.

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

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

The description is extremely concise with two sentences: the first states the purpose, and the second provides usage guidance. Every sentence adds value, no filler words. It is front-loaded and easy to parse.

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

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

The description covers the tool's context (inbox composer, inbound events, replyPolicy) and explains what it does not do. Given the output schema exists, return value explanation is not needed. It misses some details like error behavior or interaction with other tools, but overall is sufficiently complete for a creation tool with well-documented parameters.

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

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

Schema description coverage is 100%, so the schema already documents all parameters. The description adds overall context by mentioning replyPolicy='suggest', which relates to the sourceMessageId parameter, but does not provide new per-parameter semantics beyond the schema. Baseline 3 is appropriate.

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

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

The description clearly states the verb 'Create' and the specific resource 'draft reply suggestion' that appears inline in the FavCRM Inbox composer. It distinguishes from sibling creation tools like create_note or create_invoice by specifying the exact use case (reply suggestion in inbox composer), making the purpose unambiguous.

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

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

The description explicitly states when to use this tool ('for message.inbound events with replyPolicy="suggest"') and what it does not do ('does not send anything to the customer'). This provides clear usage context, though it could be more explicit about when not to use it (e.g., avoid for outbound messages).

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 a write operation (readOnlyHint=false) and non-destructive (destructiveHint=false). The description adds return value ('Returns the new invoiceId') but does not disclose potential side effects like email notifications or customer balance updates. Beyond annotations, the description adds minimal behavioral context.

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

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

The description is two sentences, front-loaded with the primary action, and contains no unnecessary words. It efficiently conveys the tool's purpose and output.

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

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

Given the tool's moderate complexity (5 parameters, 1 required), the description adequately covers the creation action and return value. However, it could mention idempotency (annotations indicate non-idempotent) or that invoice creation may have downstream effects. The presence of an output schema partially compensates, but the description could be more complete.

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

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

Schema coverage is 100%, so the description does not need to explain each parameter. The description adds 'Optionally include line items inline', which aligns with schema but is not essential. Baseline of 3 is appropriate since parameter meanings are fully captured by 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 creates a new invoice for a customer, with optional inline line items, and returns the invoice ID. This distinguishes it from siblings like 'delete_invoice', 'list_invoices', and 'update_invoice'.

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

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

The description implies usage for creating invoices with optional line items, but does not explicitly state when to use this over alternatives (e.g., creating line items separately) or provide prerequisites or conditions for use.

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

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

Annotations already indicate readOnlyHint=false (write operation) and destructiveHint=false. The description adds that it 'adds' a note, which is consistent but does not disclose additional behavioral traits such as whether the note is appended or replaces existing notes. With annotations covering the basic safety profile, the description provides minimal extra value.

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

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

The description is a single, succinct sentence that fully conveys the tool's purpose without unnecessary words. It is front-loaded and efficient.

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

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

Given the existence of an output schema and annotations, the description is minimally adequate. It names the entity types but does not mention whether the target entity must exist or how notes are associated. While the schema covers parameters, additional contextual details (e.g., that notes are attached to an entity's timeline) would improve completeness.

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

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

Schema description coverage is 100%, so the baseline is 3. The description does not add parameter-level details beyond what the schema provides (e.g., entityType enum values). It merely restates the entity types, which are already in the schema. No additional semantic enrichment.

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

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

The description clearly states the action ('Add a note') and specifies the target entities (member/account, booking, ticket, or invoice), distinguishing it from other create_* tools that create different resources. The verb 'add' aligns with the tool name 'create_note' and provides unambiguous 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 implies usage when needing to attach a note to one of the listed entity types, but it does not provide explicit guidance on when not to use (e.g., if the entity does not exist) or mention alternatives like list_notes for reading. The context is clear but lacks exclusions or prerequisites.

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

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

Annotations already indicate non-destructive and not read-only, but the description adds value by stating 'as draft', suggesting it's safe and not final. However, no further behavioral traits like permissions or rate limits are disclosed.

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

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

Single sentence with no extraneous words. Front-loaded with the key purpose and essential details. Efficient and 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 complexity (6 params, nested objects, enums) and the presence of an output schema, the description provides a high-level summary but lacks details like default state or behavior when optional fields are omitted. Output schema might compensate but is not shown.

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 schema fully documents parameters. The description briefly mentions trigger type, conditions, and products, which maps to existing schema properties but does not add new meaning beyond the schema.

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

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

Description clearly states the action (create) and resource (offer rule) with a specific context (upsell/cross-sell as draft). It distinguishes from sibling tools like list_offer_rules and get_offer_rule which are read-only.

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?

Description implies usage for creating a draft offer rule, and the context is clear. However, it does not explicitly state when not to use this tool or mention alternatives like updating an existing rule, but given the sibling list, no update tool exists, so it's sufficient.

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

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

Annotations already indicate it is a write operation (readOnlyHint=false) with no destructive or idempotent guarantees. The description adds the behavioral detail that the id parameter is for migration and can accept non-standard formats. No contradictions with annotations.

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

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

Two sentences, highly concise. The purpose is front-loaded, and every word earns its place. No unnecessary details.

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 full schema descriptions and output schema, the description is fairly complete. It covers the primary action and the key optional parameter. Could mention permissions or side effects, but not essential for creation tools.

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

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

Schema description coverage is 100%, so each parameter is already documented. The description adds value by clarifying the purpose of the id parameter for legacy migration, but does not elaborate on other parameters 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 'Create a shop outlet/location', using a specific verb and resource. It distinguishes from siblings like update_outlet and list_outlets. The mention of optional id for migration adds specificity.

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 guidance on when to use the id parameter for legacy migration but does not elaborate on when to use this tool versus alternatives or when not to use it. The context of creation is implicit but lacks explicit usage boundaries.

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 non-readOnly and non-destructive. The description adds that it creates Stripe links for two scenarios, but does not disclose side effects (e.g., redirecting user), authentication needs, or the requirement that confirm=true. This is adequate but not rich.

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

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

Two concise sentences: first sentence states the function, second provides a usage condition. No redundant or irrelevant content.

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

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

Given the existence of an output schema, the description covers the dual behavior and usage condition. It does not mention the return type (URL) or the confirm requirement, but these are partially covered in the schema. Overall, fairly 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 input schema has 80% coverage with individual parameter descriptions. The description does not add significant meaning beyond the schema (e.g., explaining the confirm parameter's role). Baseline 3 is appropriate.

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

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

The description clearly states it creates a Stripe Checkout link for new subscriptions and a Stripe Billing Portal link for existing subscriptions. It distinguishes itself from sibling tools like create_subscription by focusing on link generation, but does not explicitly contrast with that sibling.

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

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

The description provides explicit usage guidance: 'Use only after the user explicitly asks to upgrade or fix billing.' This gives clear context. However, it does not mention when not to use or suggest alternatives.

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

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

Annotations indicate a non-read-only, non-idempotent creation operation, which matches the description. The description adds useful behavioral details such as auto-derived excerpt from blocks, slug auto-generation with collision handling, and a warning against placing JSON in excerpt, going beyond what annotations provide.

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

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

The description is front-loaded with the core purpose and uses concise sentences. Every sentence adds specific value (prerequisites, auto-derivation, meta usage). No redundant or fluff content.

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

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

Given the high schema coverage and the existence of an output schema, the description covers the essential workflow: prerequisites, parameter behaviors, and warnings. It does not explain return values, which is acceptable. It provides sufficient context for an agent to use the tool correctly.

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

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

Schema description coverage is 100%, but the description adds value by clarifying excerpt behavior and the expected structure for meta. It also warns about JSON misuse, which is not present in the schema. This provides meaningful context beyond the schema 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 states the tool creates a new CMS post, specifying the supported post types (blog_post, page, custom). It mentions related tools (list_post_types, create_post_type) for discovery, which helps distinguish it from sibling tools, though it could explicitly contrast with update_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?

It explicitly states prerequisites: the post type must already exist, and guides the user to list_post_types or create_post_type if needed. It also explains how to handle custom fields via meta. However, it does not mention when to use alternatives like update_post or clone.

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

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

Annotations already indicate readOnlyHint=false, destructiveHint=false, etc. The description adds context about prerequisites and follow-up actions but does not disclose behavioral traits like idempotency or side effects beyond what is obvious from the purpose.

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

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

The description is three sentences, each adding value: purpose, prerequisite, follow-up and warning. It is front-loaded and free of 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?

Given the tool's complexity (10 parameters, output schema exists) and sibling tools, the description covers the essential workflow steps and a key storage guideline. It omits return value details, but the output schema handles that. Slightly incomplete regarding potential 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?

Schema coverage is 100% with all parameters described. The description does not add significant meaning beyond the schema; it merely echoes the schema's note on slug auto-derivation. 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 uses a specific verb 'Define' and identifies the resource 'custom post type', with examples like 'treatment' and 'service'. It clearly distinguishes from sibling tools such as create_post and create_post_type_field by stating its prerequisite role.

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 it ('Required before creating posts of that type'), what to do next ('use create_post_type_field to define its structured field schema'), and what not to do ('do not use excerpt for structured data'). It provides clear usage context and 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 explains that the field key becomes the key in meta, which is behavioral insight beyond annotations. It also details repeater usage. Annotations already indicate mutation, so the description adds useful 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?

Three sentences: purpose, key behavior, repeater guidance. No fluff. Information is front-loaded and every sentence is meaningful.

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 (9 params, nested objects) and presence of an output schema, the description adequately covers the core use case and a key special feature. It does not cover all edge cases but is sufficient for typical usage.

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

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

The input schema covers 100% of parameters with descriptions, so the baseline is high. The description adds value by explaining the key's usage in meta and the repeater pattern, which enriches understanding beyond 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 starts with 'Add a custom field to a post type schema', which is a specific verb+resource. It distinguishes from siblings like 'create_post_type' by focusing on fields. Additionally, it explains the key's role in meta and gives a usage example for repeaters.

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

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

It provides clear context by stating when to use fieldType='repeater' and advises against storing structured data in the excerpt. However, it does not exclude other scenarios or contrast with all sibling tools like 'create_custom_field'.

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 safe mutation (readOnlyHint=false, destructiveHint=false). Description adds the draft state context, which is useful but doesn't disclose additional behaviors like permissions or side 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?

Two sentences, no fluff. Essential information is front-loaded.

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

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

Given output schema exists and annotations are present, the description is adequate for a creation tool. It could mention prerequisites like being in a shop context, but overall 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?

Input schema has 100% description coverage, so the description does not add parameter details. Baseline 3 is appropriate as schema carries the burden.

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

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

The description clearly states the verb 'Create', resource 'shop product', and the state 'as DRAFT'. It distinguishes from sibling tools like create_product_category and update_product.

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?

Implies usage for initial creation with draft status, but no explicit comparisons to alternatives like update_product or when not to use it.

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

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

The description adds basic context (creation, subcategories) but no behavioral traits beyond annotations, such as permissions or side 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?

Two concise sentences with no wasted words, efficiently conveying purpose and key usage detail.

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

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

With an output schema and full parameter descriptions, the description is nearly complete; it could mention required field 'name' but remains 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 coverage is 100%, and the description only adds meaning for parentId; baseline 3 applies as schema already fully documents parameters.

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

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

The description clearly states the tool creates a product category, distinguishing it from siblings like create_category (generic) and create_service_category by specifying 'product category'.

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 guidance on using parentId for subcategories but does not explicitly state when to use this tool over alternatives like create_category.

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

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

Annotations show readOnlyHint=false, indicating mutation. Description adds behavioral details: type enum constraints, value as decimal string, and server-side uppercasing. No contradictions with annotations. Adequate but could mention creation specifics (e.g., returns created resource).

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 purpose. No redundant information. Every sentence adds value. Well-structured for quick parsing.

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 17 parameters and existing output schema, description covers core purpose and key parameter semantics. Missing explanation of optional fields (e.g., dates, limits) but schema descriptions fill that gap. Sufficient for agent to use correctly.

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

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

Schema description coverage is 100%, so baseline is 3. Description adds extra meaning beyond schema: explains the type enum and how value is interpreted (percentage or currency units). Provides context for required parameters beyond schema descriptions.

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

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

The description clearly states 'Create a promotion / discount code' with specific verb and resource. It distinguishes from siblings like update_promotion by explaining the type and value fields. The resource is well-defined.

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

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

Provides clear usage context: type can be percentage or fixed_amount, value is a string representing the discount. Notes that codes are uppercased server-side. However, no explicit guidance on when to use this tool vs. alternatives like update_promotion or validate_promotion.

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

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

Annotations already indicate this is a write operation (readOnlyHint=false) and not destructive. The description confirms 'Create' but adds no further behavioral context (e.g., idempotency, side effects). With annotations present, the bar is lower, but more detail could be beneficial.

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

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

The description is extremely concise: two sentences with no wasted words. It front-loads the core purpose and then adds relevant usage context.

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

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

Given the tool has 5 parameters (2 required) and an output schema, the description is nearly complete. It mentions the key usage context (requiresResource services). It could optionally mention linking after creation, but not required.

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

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

The input schema has 100% coverage with descriptions for all parameters. The description adds no parameter-specific details beyond the schema, so a baseline score of 3 is appropriate.

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

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

The description clearly states the tool's purpose: 'Create a bookable resource (room, equipment, vehicle).' It provides specific verb (create) and resource type with examples, distinguishing it from sibling tools like 'create_service' or 'update_resource'.

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

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

The description says 'Used by services that have requiresResource=true,' indicating when to use this tool. While it doesn't explicitly state when not to use it or list alternatives, the context is clear and sufficient for an AI agent to decide.

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

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

Annotations already indicate a mutation (create). The description adds no further behavioral details beyond the creation action and segment type distinction. It does not disclose side effects, permissions, or idempotency considerations.

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

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

Two sentences, front-loaded with the action and immediately providing key decision criteria. No redundant 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?

Despite an output schema and full parameter descriptions, the description lacks guidance on how to structure the criteria object for dynamic segments and does not mention that members must be set separately for static segments. The tool's complexity (nested object, multiple condition types) warrants more context.

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

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

Schema coverage is 100% with parameter descriptions. The description adds value by explaining the semantics of segmentType (STATIC vs DYNAMIC), which goes beyond the schema's enum description.

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

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

The description clearly states the tool creates a new customer segment and immediately distinguishes between STATIC (manual lists) and DYNAMIC (criteria-based auto-filtering), which differentiates from siblings like update_segment or set_segment_members.

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 guidance on when to use STATIC vs DYNAMIC segment types, but lacks explicit direction on when to prefer create_segment over update_segment or set_segment_members, and does not mention prerequisites or post-creation steps.

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 tool creates a service (mutation), which matches annotations (readOnlyHint=false). It mentions setting various fields but does not disclose behaviors like whether requireLogin defaults to true or the effect of requiresConfirmation. Annotations are sparse, so the description carries the burden but provides only high-level behavioral info.

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

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

Two sentences front-load the core purpose and a key usage hint. No filler. Could be slightly more structured (e.g., bullet points) but is concise and readable.

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 20 parameters and an output schema, the description is minimal. It covers high-level intent but omits important context such as payment handling, staff assignment, or tier restrictions. The output schema may compensate for return values, but the description lacks full contextual coverage.

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 each parameter has individual descriptions. The tool description adds no further semantics beyond grouping fields (duration, price, capacity, policies). Baseline of 3 applies as schema already handles parameter meaning.

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

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

Clear verb+resource ('Create a bookable service'). Distinguishes from siblings like update_service and create_service_category by specifying it creates a new service. The description also lists key attributes (duration, price, capacity, policies).

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 helpful prerequisite: 'Use list_service_categories first if you want to attach to an existing category.' This guides the agent on when to call a sibling tool. However, it does not explicitly compare with other creation tools or state when not to use this tool.

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

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

Annotations indicate readOnlyHint=false and destructiveHint=false, but the description adds no behavioral context beyond creation. It does not mention authorization requirements, side effects, or rate limits, which is a gap for a mutation tool.

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

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

Single, well-formed sentence with no redundancy. Every word adds value. Front-loaded with verb and resource.

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

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

Given 3 parameters and an output schema, the description is adequate but could mention common use cases or that categories are typically used to organize services in a menu. Still complete enough for a simple create tool.

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

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

Schema coverage is 100%, so the description adds no extra meaning beyond the schema's parameter descriptions. The description's mention of grouping contributes minimally to parameter understanding.

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

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

The description clearly states the verb (Create), resource (service category), and provides concrete examples (Treatments, Classes) to group bookable services. It distinguishes from siblings like create_category (general) and create_product_category.

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

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

The description implies the tool is for grouping bookable services but does not explicitly state when to use this tool over alternatives like create_category or list_service_categories. No exclusion or 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?

The description discloses the core behavior (create a package) which aligns with annotations (readOnlyHint=false, destructiveHint=false). It adds a usage hint but does not elaborate on side effects, permissions, or error conditions. Given annotations cover the basic traits, the description adds moderate value.

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

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

Two sentences with no extraneous information. The first sentence states the purpose, the second provides a key usage tip. Front-loaded and efficient.

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

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

Given the tool has 8 parameters, 4 required, and an output schema, the description is brief. It explains the concept of a prepaid session bundle and the applicableType mechanism, but lacks detail on how sessionCount and validDays interact or default behaviors. Adequate but not comprehensive.

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

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

Schema coverage is 100%, so baseline is 3. The description adds context specifically for applicableType and applicableItems, clarifying their use together. Other parameters (name, price, sessionCount, etc.) are already described in schema, so overall the description provides limited additional meaning.

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

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

The description clearly states the tool creates a 'service package/prepaid session bundle', providing a specific verb and resource. It distinguishes from sibling create tools by specifying the type, and includes a usage hint about applicableType, making the purpose unambiguous.

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

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

The description gives a specific tip about when to use applicableType=SELECTED, but does not explicitly guide when to use this tool versus alternatives like list_service_packages or update_service_package. Usage context is implied but not directly stated, earning a mid-range score.

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

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

Annotations already indicate readOnlyHint=false and destructiveHint=false, so the description's 'Create' is consistent. However, it does not add behavioral context like permissions needed or side effects beyond what the schema provides.

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

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

The description is a single concise sentence (12 words) that is front-loaded and efficient, with no wasted words.

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

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

Given the tool has 12 parameters and an output schema, the description is adequate but minimal. It could mention the required parameters (serviceId, date, startTime, endTime) for completeness, but the schema covers them.

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 description adds no new meaning beyond summarizing that recurrence is supported. Baseline 3 is appropriate.

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

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

The description clearly states the tool creates a bookable schedule window for a service with recurrence options, which distinguishes it from sibling tools like list_service_schedules or update_service_schedule.

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

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

The description provides no guidance on when to use this tool versus alternatives such as set_staff_availability or set_resource_availability, nor does it mention any prerequisites or exclusions.

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

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

Annotations already indicate this is a write operation (readOnlyHint=false, destructiveHint=false). The description adds meaningful context by specifying 'non-renewing' and contrasting with provider-backed billing, but does not disclose further side effects or permissions. This extra context justifies a 4.

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

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

Two concise sentences with the verb and resource front-loaded. Every word earns its place, and the alternative guidance is packed efficiently. It is not verbose or over-specified.

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 8 parameters but full schema descriptions and an output schema, the description sufficiently covers the tool's key context. It clarifies the edge case of provider-backed recurring billing, though it doesn't explain the return value. This is complete enough for a tool with rich structured metadata.

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

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

The input schema has 100% coverage, so the baseline is 3. The description does not add parameter details beyond the schema, but it reinforces the non-renewing nature (autoRenew const false). This meets the baseline but adds no extra semantic value.

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

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

The description clearly states the tool's purpose: 'Create a manual, non-renewing subscription record for a member.' This distinguishes it from provider-backed recurring billing, and the 'create' verb + resource is specific. It contrasts with sibling tools like create_plan_upgrade_link or enrol_membership.

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 an alternative usage: 'Use a subscription action link for provider-backed recurring billing.' This tells the agent when not to use this tool and points to a different approach, providing clear usage context.

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

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

Annotations already indicate this is a write operation (readOnlyHint=false, destructiveHint=false). The description adds value by clarifying that the survey is not automatically published unless the status is set, which is important behavioral context. No contradictions.

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

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

Two succinct sentences that are front-loaded and convey the essential purpose and a key decision point. No wasted words.

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

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

Given the presence of an output schema and full schema coverage, the description is adequately complete. It explains the core action and the main branching choice (publish later vs. now). Minor gap: doesn't explicitly state the default status if 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 100%, so baseline is 3. The description adds minor value by mentioning 'custom question blocks' and the status option for publishing, but does not significantly expand on individual parameter meanings 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 'Create a survey with custom question blocks' and mentions immediate portal access upon publishing. It distinguishes from sibling tools like 'archive_survey' and 'update_survey' by focusing on creation and publish options.

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 usage context by mentioning the ability to publish later or immediately. However, it lacks explicit guidance on when not to use this tool or how it compares to alternatives like 'update_survey'.

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