Dashform MCP Server

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

The description adds useful behavioral context beyond annotations: it states that the tool returns DNS instructions and that permission is owner/admin only. This complements the annotations (readOnlyHint=false, openWorldHint=true) without contradicting them. It also implicitly explains the external side effect of DNS changes without being overly detailed.

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, tight sentence that front-loads the action and required permission, then mentions the DNS instructions return. No wasted words; it effectively communicates all key information in a compact form.

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 tool with no output schema and minimal annotations, the description covers essential aspects: the action, the scope, permission, and return value. It lacks explicit handling of edge cases (e.g., duplicate domains), but that is not critical for invocation. Overall, it provides what an agent needs to call the tool correctly.

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

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

With schema description coverage at 0%, the description must compensate for the single 'domain' parameter. It provides minimal guidance—just that it's a 'custom domain'—but does not specify format (e.g., no protocol, example.com) or any constraints. The parameter is a simple string, so the gap is modest, but the description could be more explicit to fully compensate for the missing schema detail.

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 ('Add') with a clear resource ('custom domain') and scope ('to the active org'), and notes the return of DNS instructions. It distinguishes itself from siblings like remove_custom_domain and verify_custom_domain through this explicit action and context.

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 specifies the audience restriction ('Owner/admin only'), which is a clear prerequisite. While it doesn't explicitly contrast with alternatives, the sibling names are self-explanatory and the description implies this is the add operation among related domain tools. The context is sufficient for an agent to know when to use it.

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

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

Annotations already declare readOnlyHint=true and destructiveHint=false, so the safety profile is covered. The description adds that the tool queries the form's data and returns the analytics assistant's answer, which is mild additional context, but it does not disclose latency, cost, token limits, or potential variability in answer quality despite openWorldHint=true.

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

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

Two tightly written sentences with zero waste. The primary action is front-loaded, and the return behavior is stated in a single follow-on clause. Nothing extraneous is present.

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 readOnly two-parameter tool with no output schema, the description covers the core operation adequately. Minor gaps remain: no indication of return format and no note on how the openWorldHint affects expected answer scope, but these are non-critical for a straightforward chat-style query 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 50% — only 'question' is documented, and the description adds nothing about either parameter. The parameters (formId, question) are fairly self-explanatory, so the gap is tolerable, but the description makes no effort to compensate for the undocumented formId.

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

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

The description states a clear verb (Ask) and resource (a form's replies), and specifies the natural-language nature of the query. It is distinct enough from siblings like get_replies_insights by emphasizing 'natural-language question', but it does not explicitly name or contrast any sibling, so it falls just short of full differentiation.

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

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

The description implies the use case (asking analytical questions about replies) but provides no explicit when-to-use guidance, no exclusion conditions, and no named alternatives. Given that a closely related sibling (get_replies_insights) exists, explicit routing guidance would materially help an agent.

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

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

The description discloses that the delete is permanent and requires a confirm flag to proceed, which adds valuable safety context beyond the annotations (destructiveHint=true). It also communicates the batch limit of 100 replies, enhancing 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 a single, front-loaded sentence with no waste. It conveys all essential information efficiently.

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

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

For a destructive batch operation with no output schema, the description covers the action, the limit, and the confirmation requirement. It is sufficient for an agent to select and invoke the tool correctly without further elaboration.

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 low (33%), but the description adds meaning to key parameters: 'up to 100 replies' clarifies the ids array limit, and 'Pass confirm: true' explains the confirm flag's role. formId remains self-explanatory from context.

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

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

The description clearly states the tool's function: 'Permanently delete up to 100 replies of a form.' It uses a specific verb ('delete'), identifies the resource ('replies of a form'), and specifies a limit ('up to 100'), which distinguishes it from singular delete_reply and other delete 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 implies usage for batch deletion but does not explicitly state when to use this tool versus alternatives like delete_reply. It does provide a required action ('Pass confirm: true to proceed'), which is a usage prerequisite, but lacks comparative guidance 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?

The description discloses key side effects not fully captured by annotations: 'Creates a reply record visible in the dashboard and triggers connected integrations (CRM, email, webhooks).' This adds meaningful context about persistence and external effects. While annotations already indicate a non-read-only operation, the description enriches understanding without contradicting them.

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

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

The description is concise and well-structured: a clear purpose sentence followed by two supporting sentences on behavior and compatibility. Every sentence adds value, and there is no redundancy or extraneous 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 tool with 7 parameters, nested objects, and no output schema, the description provides essential context: how to use answers, what side effects occur, and the legacy option. It lacks details on output/return values or error cases, but given the presence of annotations and no output schema, the description covers the core usage 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?

With 57% schema description coverage, the description partially compensates by explaining the 'answers' parameter ('keyed by question keys from get_form_questions') and the legacy 'lead' object. However, it does not add meaning for parameters like notes, metadata, fit_score, or service_name, which rely on schema descriptions. Some improvement is still needed for full semantic clarity.

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: 'Submit a lead's information to request an appointment.' It also specifies that it creates a reply record and triggers integrations, differentiating it from generic reply creation or other lead-related tools. The mention of using question keys from get_form_questions provides a clear connection to a sibling tool, further clarifying its unique 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 provides strong usage context by instructing to 'Provide answers keyed by question keys from get_form_questions,' implying a prerequisite call. It also notes the legacy lead object for backwards compatibility, helping users decide between parameters. However, it does not explicitly state when to prefer this tool over alternatives like create_reply or check_fit, leaving some room for ambiguity.

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

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

Annotations already declare readOnlyHint=false and destructiveHint=false, so the description doesn't need to repeat safety. It adds useful context by noting it 'saves the requested draft edits' (mutation) and returns a summary plus updated form. However, it does not disclose whether edits overwrite the draft, require permissions, or are reversible. With annotations covering the base, a 3 is appropriate.

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 one clear sentence, front-loaded with the main action, and efficiently conveys the workflow. No fluff, but it could be sharper by explicitly naming the output. It's appropriately concise without sacrificing key information.

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

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

For a mutation tool with no output schema, the description covers the main return value (summary + updated form) and explains the workflow. It omits details like error conditions, whether the form must exist, and any side effects beyond draft edits. Given the simplicity of inputs (2 params) and annotations covering safety, this is adequate but not complete.

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

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

Schema coverage is only 50% (instruction has a description, formId does not). The description does not add meaning for formId beyond identifying the form, and it doesn't elaborate on instruction format or constraints beyond 'focused'. Since schema coverage is low, the description should compensate, but it barely adds value for either parameter. Baseline would be 3 if coverage were high, but here it's insufficient.

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

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

The description clearly states a specific verb ('Edit a form') and resource ('form'), and distinguishes it from sibling 'update_form' by framing it as instruction-based ('from one focused instruction') and mentioning the summary return. This lets an agent pick it over the more generic update_form without opening either schema.

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

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

The description implies usage for natural-language-driven editing ('one focused instruction') and explains the workflow (reads, saves edits, returns summary). However, it doesn't explicitly state when NOT to use it (e.g., for bulk edits or direct programmatic updates) or mention alternative tools like update_form. Clear context but no exclusions.

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

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

Annotations already declare readOnlyHint=true and destructiveHint=false. The description adds valuable behavioral details: the return payload (score, fit assessment, confidence, reasoning, next action) and legacy lead object support. This goes beyond what annotations alone provide, though it doesn't cover rate limits or error cases.

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

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

Three sentences, front-loaded with the primary action, and every sentence delivers distinct information (purpose, input/output, legacy compatibility). No redundancy or filler.

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

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

The description covers the essential context: what to provide, what it returns, and legacy support. With no output schema, it adequately conveys return values. It doesn't explicitly state the prerequisite step of calling get_form_questions first, but the mention of question keys implies it, leaving only a minor workflow gap.

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

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

All parameters have schema descriptions, so the baseline is 3. The tool description largely repeats the answers format ('keyed by question keys from get_form_questions') and legacy lead object, adding no new details like value constraints or examples 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 opens with a specific verb+resource ('Evaluate lead fit against this business') and clearly specifies the output (score, fit assessment, confidence, reasoning, next action). Referencing get_form_questions differentiates it from sibling tools like rescore_form_replies or override_verdict, making its 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 clearly implies a workflow: fetch question keys via get_form_questions, then provide answers keyed by those keys. It also warns that the lead object is legacy. However, it does not explicitly name alternatives or state when not to use the tool, so it stops short of full 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 beyond annotations: start/end screens are added automatically unless supplied, 'structured' is the default type, and the tool does not publish. Annotations are minimal (readOnlyHint false, destructiveHint false) so the description carries the burden; it provides useful defaults and side-effect info but does not detail failure modes or idempotency.

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 with no filler. The primary action is front-loaded, and the most critical behavioral details (default type, auto-added screens, publish call) are stated compactly. Every sentence earns its place.

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

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

For a complex creation tool with one large object parameter, the description covers the essential workflow: full creation, type distinction, automatic screen handling, and the publication step. It does not mention potential error scenarios or return behavior, but given no output schema and the schema's rich property descriptions, these omissions are minor. The description sufficiently completes the context an agent needs to call it correctly.

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

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

The single parameter 'form' has no description itself (0% coverage at parameter level), but the tool description adds context about the purpose of the structure ('name, steps, theme and settings') and explains the two type values ('structured' = Logic Funnel, 'dynamic' = AI Funnel). This adds value beyond the schema, though the nested property descriptions are already rich; the description mainly orients the agent on the overall intent.

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

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

States a specific verb ('Create') and resource ('a complete form') and enumerates the included components ('name, steps, theme and settings'). Clearly distinguishes from siblings like update_form and publish_form by framing it as a one-call creation and explicitly deferring publication to publish_form. The description makes the tool's role unambiguous.

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

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

Provides clear context: creation in one call, and explicitly instructs to 'Call publish_form afterwards to take it live,' which routes agents to the correct follow-up tool. However, it does not explicitly describe exclusions or alternatives (e.g., when to use update_form for edits), leaving some inference required.

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

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

Annotations only provide readOnlyHint=false and destructiveHint=false, which already signal a non-read, non-destructive operation. The description adds that it maps form answers to columns, but does not disclose side effects (e.g., how existing integrations are affected, whether the operation is additive or requires specific permissions). No contradictions with annotations, but the description fails to add meaningful behavioral disclosure beyond the annotation flags.

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

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

The description is a single, efficient sentence that front-loads the core purpose ('Create a spreadsheet-style integration') and adds the mapping behavior without superfluous detail. It earns its place 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 4 required parameters, no output schema, and zero schema description coverage, the description is far from complete. It omits explanation of connectionId and formId, does not specify the allowed defaultColumns values, and lacks guidance on how fieldMapping should be structured. An agent would struggle to construct a correct request without additional lookups.

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

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

Schema description coverage is 0%, so the description must compensate for the undocumented parameters. It mentions 'mapping form answers to columns' which hints at fieldMapping and defaultColumns, but does not explain connectionId or formId, nor the structure of fieldMapping (column, formFieldId, ordinal). The description adds minimal semantic meaning beyond the schema property names.

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

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

The description clearly states a specific verb ('Create'), a resource ('integration'), and qualifiers ('spreadsheet-style ... on a form, mapping form answers to columns'). It distinguishes from sibling create_integration_from_config by focal use of 'on a form' and mapping behavior, though the sibling is not named explicitly.

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

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

The description gives context on what kind of integration is created (spreadsheet-style) but provides no explicit guidance on when to use this tool versus alternatives like create_integration_from_config. No prerequisites, exclusions, or conditions are mentioned, leaving the agent to infer appropriate usage from the generic 'create' phrasing.

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 (mutation) and openWorldHint=true, so the description's 'Create' is consistent but adds no extra behavioral context. It does not disclose what happens on success (return value, confirmation), whether the operation is idempotent, or any side effects like triggering webhooks or sending emails (though it's only creating the config). It adds minimal value beyond the annotation.

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 (one sentence) but not particularly well-structured. It includes a parenthetical list that is incomplete and misleading, and it front-loads the verb and resource, which is good. However, it lacks any attempt to structure information (e.g., bullet points) or highlight critical constraints. It earns a middle score because brevity is fine but content is weak.

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

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

This is a complex tool with 3 required parameters and a massive actionConfig schema with 9 oneOf variants. The description provides almost no context: it doesn't mention that actionConfig must match one of the allowed kinds, that connectionId must refer to an existing connection, or that some kinds require additional target objects (like spreadsheetId for Google Sheets). Without an output schema and with zero parameter documentation, the description is utterly inadequate for an agent to successfully construct a valid request.

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

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

Schema description coverage is 0% — the description adds nothing about the parameters. It only says 'from a full action config' without explaining the structure of actionConfig, which is highly complex with many oneOf variants. The schema itself documents each variant in detail, but the description does not help an agent understand which kinds are available, what fields are required per kind, or how connectionId and formId relate. Significant gap.

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

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

The description states a specific verb ('create') and resource ('integration on a form') and lists several integration types. However, it inaccurately labels them 'message-style' when the schema includes row-append types (Google Sheets, Airtable, Notion) and omits Email and others from the schema. It partially distinguishes from the sibling 'create_integration' by mentioning 'from a full action config', so it's fairly clear but not fully accurate.

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 is given on when to use this tool versus alternatives like 'create_integration' or 'create_webhook_connection'. The description does not mention prerequisites, such as having a connectionId, nor does it explain the scenarios for which this config-based approach is appropriate. Purely implicit that it's for creating from a full config.

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, aligning with the 'create' action. The description adds the constraint that it targets the latest published version, which is useful behavioral context. Beyond that, it does not disclose potential side effects, validation behavior, or error handling. Given the annotations are minimal (only flattening the mutation nature), the description carries some burden but does not fully disclose behavioral nuances.

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 front-loads the core action and then mentions optional capabilities. There is no fluff or redundancy; every word earns its place. It is appropriately concise for the tool's complexity.

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

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

For a tool with six parameters, a nested object, and no output schema, the description is too sparse. It does not explain the purpose of specific parameters like status or respondent emotion, assume knowledge of the answer format (which is complex, involving multiple question types and value encodings), or describe what the response looks like. The absence of an output schema increases the need for behavioral description, which is missing. The brief mention of seeding answers is insufficient for an agent to correctly invoke the tool without relying heavily on 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 only 33% (data and formId have descriptions), yet the tool description only vaguely mentions 'seed respondent info and answers (question key -> value)', which overlaps with the data schema description. It does not explain the other parameters (status, respondentName, respondentEmail, respondentEmotion) or their formats, nor does it compensate for the lack of schema descriptions for those fields. The description adds minimal value beyond what the schema already 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 action ('Create a reply') and the resource (a reply on the form's latest published version). It also mentions optional seeding of respondent info and answers, giving a precise scope that distinguishes it from other tools like create_form. The verb and resource are specific, making the purpose unmistakable.

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

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

The description gives clear context that this tool operates on the latest published version of a form, implying when it should be used (e.g., not for draft versions). However, it does not explicitly name alternatives or provide exclusions for when not to use it. Since there are no sibling tools for creating replies, the lack of explicit alternative routing is acceptable, but the guidance could be more detailed.

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 adds the useful 'no OAuth' constraint, which is behavioral context not present in annotations. However, it doesn't disclose other behaviors such as persistence, return values, or side effects on existing connections, leaving some burden unmet.

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

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

The description is two concise, front-loaded sentences with no filler. The primary purpose is stated first, and the exclusion of OAuth is provided as a clear second point. Every word contributes to understanding the tool's scope.

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

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

For a tool with no output schema and 0% parameter descriptions in the schema, the description should clarify return values, side effects, and parameter semantics. It only covers the tool's purpose and a brief usage note, omitting crucial details like what happens after creation (e.g., whether a connection ID is returned) and the meaning of 'accountLabel'. This is inadequate for an agent to confidently invoke the tool without guessing.

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

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

Schema description coverage is 0%, so the description must compensate for parameter clarity. It does not mention any of the three parameters (url, provider, accountLabel). While 'provider' has an enum and 'url' is self-explanatory, 'accountLabel' is ambiguous and unexplained. The description adds zero value beyond the schema, failing to fill the gap.

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

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

The description states a specific verb and resource: 'Create a webhook or Discord connection'. It also distinguishes from OAuth-based connections, which helps an agent understand its scope. However, it does not explicitly name sibling tools like create_integration, so differentiation relies on the 'no OAuth' qualifier rather than an explicit reference.

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

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

The description gives clear usage context: it's for webhook/Discord connections and explicitly says to use the dashboard's OAuth flow for other providers like Slack, HubSpot, Mailchimp. This tells an agent when to avoid this tool, though it doesn't explicitly name alternative tools or provide conditions beyond provider type.

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

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

Annotations already declare destructiveHint=true and idempotentHint=true, so the safety profile is covered. The description adds the crucial confirm:true requirement, telling the agent that deletion requires explicit confirmation, which is a behavioral safeguard. 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 short sentences front-load the purpose and the necessary confirmation step. Every word earns its place; no redundancy or filler.

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

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

For a simple delete operation, the description plus annotations cover the essential context: what gets deleted (blob by URL), the required confirmation, and the destructive nature. No output schema is needed for a void operation, and the confirm flag is properly highlighted. Could include side effects or irreversibility, but that's already inferred from destructiveHint.

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

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

Schema coverage is only 50% (confirm has a description, url does not). The description adds meaning to url by specifying 'by its URL' and to confirm by saying 'Pass confirm: true to proceed.' This compensates for the sparse schema, making both parameters self-explanatory.

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

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

The description uses a specific verb 'Delete' and resource 'a blob' identified by URL. It clearly distinguishes from sibling delete tools (delete_chat, delete_form, etc.) by specifying the target type. Also mentions confirm requirement, adding clarity.

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

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

The description implies when to use—when you need to delete a blob by URL. However, it doesn't explicitly contrast with alternative delete tools or provide exclusions, leaving the decision to the agent based on resource type. Since the resource type is unique, the context is inherent but not explicitly stated.

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

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

Annotations already provide destructiveHint=true and readOnlyHint=false. The description adds valuable context: the deletion is permanent, requires confirm:true, and cascades to integrations. It does not contradict the annotations and elaborates on destructive behavior.

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

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

Two short sentences, front-loaded with the core action and the critical confirmation requirement. Every word earns its place; no redundancy or fluff.

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

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

The description covers permanence, confirmation, and cascading deletion, which is strong for a destructive tool. However, it omits mention of the revoke_connection alternative and behavior for non-existent connections, leaving some ambiguity for an agent.

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

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

Schema has 50% description coverage, with confirm's purpose already documented. The description reinforces the confirm requirement but adds no new meaning for id, which remains undocumented in the schema. It provides marginal value beyond the schema.

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

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

The description clearly states it permanently deletes a connection and its integrations, using a specific verb and resource. It does not explicitly name alternative tools like revoke_connection, but the word 'permanently' hints at a distinction, preventing a 5.

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

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

No guidance is given on when to use this tool versus alternatives, such as revoke_connection or delete_integration. The description only explains the action, not the context or conditions for choosing it.

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

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

Annotations already set destructiveHint=true and idempotentHint=true, but the description adds meaningful specifics: the permanent nature, the deletion of all versions and replies, and the requirement to pass confirm:true. This goes beyond the annotations.

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

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

A single well-structured sentence delivers all essential information: action, scope, and the confirm prerequisite. No wasted words.

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

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

For a simple delete tool, the description is complete. It covers the destructive scope, the permanent nature, and the confirm gate. No output schema is needed for a delete operation, and the sibling context does not introduce ambiguity.

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 documents both parameters with full coverage (100%). The description redundantly emphasizes 'Pass confirm: true to proceed' but does not add new meaning beyond what the schema provides. Baseline 3 is appropriate.

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

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

The description clearly states the action ('Permanently delete'), the resource ('a form'), and the full scope ('all its versions and replies'). This distinguishes it from sibling tools like delete_reply and batch_delete_replies.

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 delete an entire form and its associated data) and mentions the confirm gate, but it does not explicitly contrast with alternatives like delete_reply or list_forms. The usage context is clear but not fully explicit about when not to use it.

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

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

Beyond the annotations (destructiveHint true), the description adds the permanent nature of the deletion and the confirmation requirement via confirm: true, which is not captured in the annotations.

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

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

The description is a single, well-structured sentence that immediately conveys the action and the required confirmation flag.

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

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

Given the tool's simplicity and the annotations covering destructive/idempotent behavior, the description adequately covers the main usage. It does not explain return values, but no output schema exists and the behavior is straightforward.

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 references confirm but merely restates the schema's existing description. The id parameter lacks any description in the schema, and the description does not compensate by explaining how to identify the integration.

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

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

The description uses the specific verb 'delete' with the resource 'integration from a form', clearly distinguishing it from sibling tools like toggle_integration and list_integrations.

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 indicates the primary usage—permanent deletion—and instructs to pass confirm: true, but it does not explicitly mention alternatives or 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?

Description explicitly discloses permanence and requires confirm:true, adding a safety guardrail beyond the annotations' destructiveHint and idempotentHint. 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?

Two short sentences, front-loaded with the core action and immediately followed by the critical confirmation requirement. Every word earns its place.

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

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

For a simple delete operation with two well-documented parameters and appropriate annotations, the description provides everything needed to invoke correctly. No output schema needed.

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

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

Schema covers both parameters with descriptions, and the description's confirm instruction largely repeats schema's 'Must be true to delete'. No additional semantic value beyond schema.

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

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

Description states 'Permanently delete a single reply' with a specific verb and resource, clearly distinguishing it from batch operations like batch_delete_replies.

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

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

The phrase 'a single reply' implies usage for one deletion at a time, but no explicit comparison or alternative is mentioned. Context is present but not fully developed.

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

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

Annotations already declare destructiveHint=true and readOnlyHint=false, covering the destructive nature. The description adds valuable behavioral detail by requiring confirm: true to proceed, which is a safety mechanism not present in annotations. It also clarifies permanence, aligning with the destructive hint.

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 exceptionally concise—two sentences with no filler. It front-loads the destructive nature and the confirmation requirement immediately, making it efficient for an agent to parse.

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

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

For a destructive tool with no output schema, the description is adequate but minimal. It states permanence and the confirm requirement, but does not mention possible errors, side effects beyond deletion, or what happens if the hook doesn't exist. Given the simplicity, annotations cover much, but a note on error behavior 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 50% (only confirm has a schema description). The description redundantly mentions 'Pass confirm: true to proceed' which adds no new information over the schema. It fails to compensate for the undocumented hookId parameter, providing no additional semantic guidance for it.

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

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

The description clearly states the action (permanently delete) and the specific resource (Zapier webhook subscription), making its purpose unambiguous. It also differentiates from siblings like toggle_zapier_hook and list_zapier_hooks by the 'permanently delete' phrasing.

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 (deletion) but does not explicitly contrast it with alternatives such as toggle_zapier_hook or provide any when-not-to-use guidance. While the intent is obvious from the name, no explicit routing is given.

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

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

Annotations already indicate readOnlyHint=true and destructiveHint=false, but the description adds useful context by explaining the return value: a booking link if configured, or a message about scheduling. This goes beyond the annotations to clarify what the agent can expect, though it doesn't mention any side effects or error scenarios.

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

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

The description is concise and well-structured: two sentences that immediately state the purpose and then the expected return values. No unnecessary information, making it easy for an agent to parse quickly.

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

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

For a simple tool with one parameter, full schema coverage, and clear annotations, the description provides enough context. It explains the output type (link or message), which is crucial given the absence of an output schema. The description is complete for an agent to invoke this tool correctly.

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

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

The schema already provides a complete description for funnel_id ('The funnel public ID or internal ID'), covering 100% of parameters. The tool description adds no additional parameter meaning, so the baseline score of 3 is appropriate.

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

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

The description clearly states the tool's purpose: 'Get booking availability for this business.' It specifies the verb (get) and resource (booking availability) and distinguishes it from sibling tools like book_appointment by focusing on availability rather than the booking action.

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

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

The description implies that this tool is for checking availability, suggesting an alternative for booking (book_appointment), but it does not explicitly state when to use this tool versus alternatives. The context is understandable but not definitively differentiated.

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

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

Annotations already declare readOnlyHint=true and destructiveHint=false, so the safety profile is covered. The description adds value by listing the returned fields and clarifying the target entity, but does not go into error cases or pagination.

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, action-first, with no wasted words. The first sentence states what the tool does and the second gives a concrete use case.

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

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

For a simple read-only query with one parameter and no output schema, the description fully covers purpose, usage context, and the nature of the return data. It is self-contained and unambiguous.

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

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

Schema description coverage is 100% for the single funnel_id parameter, which is already well described as 'The funnel public ID or internal ID'. The tool description does not add parameter-specific detail, 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?

Clearly states it retrieves business information for a Dashform funnel and enumerates the specific fields returned (description, industry, location, services, booking link). Distinguishes from sibling get_* tools by focusing on business entity data rather than forms, chats, or connections.

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

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

Provides explicit usage context: 'Use this to understand what a business offers before checking lead fit.' This tells the agent when to call it, though it does not name alternatives or exclusion cases.

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

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

Annotations already declare readOnlyHint=true and destructiveHint=false, so the description doesn't need to restate safety. It adds the 'single by ID' scoping, which is useful context. However, it does not disclose the return format, error behavior, or any auth requirements, leaving some ambiguity. With annotations covering the safety profile, a 3 is appropriate.

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

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

A single, short sentence with no filler. It communicates the core action and scope efficiently. Every word earns its place.

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

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

For a simple getter with one parameter and no output schema, the description is minimal but arguably sufficient for basic invocation. However, it lacks information on what the returned connection object looks like and does not specify if the ID refers to a connection ID specifically. These gaps make it adequate but not complete.

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

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

The only parameter is 'id', which is described only in the schema as type string. Schema description coverage is 0%, so the description must compensate. It merely says 'by ID', which adds no meaning beyond what the parameter name implies. It doesn't clarify what kind of ID or how to format it, leaving a coverage gap.

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

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

States a specific verb and resource: 'Get a single connection by ID.' This clearly indicates it fetches one specific connection, distinguishing it from list operations like list_connections. However, it doesn't explicitly name any sibling, so it relies on the word 'single' to imply contrast.

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. There is no mention of list_connections or other get_* tools, nor any condition that selects this one. The agent must infer usage solely from the name, which is minimal guidance.

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

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

Annotations already provide readOnlyHint=true and destructiveHint=false, so the safety profile is known. The description adds meaningful behavioral context beyond annotations: the response shape is compatible with update_form, and 'unset attributes are omitted' tells the agent about the response structure. This is valuable, though it does not cover error cases or auth requirements, which are not present in annotations either.

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 zero waste. The first sentence front-loads the purpose and the authoring-vocabulary distinction; the second adds a single behavioral detail. Every clause earns its place.

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

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

For a single-parameter read-only tool with annotations covering safety, the description is complete. It communicates the exact response shape and a key serialization behavior (omission of unset attributes). An agent knows what to expect and can proceed to edit/update. No critical missing information.

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

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

Schema description coverage is 100% (the parameter 'id' is described as 'The form ID'), so the schema already documents the parameter. The description adds no additional information about the parameter, such as format, origin, or validation. Per the rubric, a baseline of 3 is appropriate when schema coverage is high.

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

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

States a specific verb ('Get') and resource ('form by ID'), and qualifies it with 'authoring vocabulary', which distinguishes it from siblings that fetch published versions or specific aspects like questions. The mention of 'the same shape update_form accepts' further implies its role in an edit workflow.

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

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

The description clearly implies when to use this tool: to retrieve the authoring-form shape that can be edited and sent back to update_form. However, it does not explicitly name alternatives like get_published_form_version or get_form_questions, relying on the sibling list for context. It gives a clear workflow but lacks explicit exclusions.

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

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

Annotations already declare readOnlyHint=true and destructiveHint=false, so the safety profile is known. The description adds value by specifying what the tool returns (keys, types, descriptions, options), which is behavioral context beyond the annotations. It stops short of disclosing potential edge cases like empty results or error handling, but this is minor for a simple read 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?

Two sentences, each earning its place: the first states purpose and return content, the second gives contextual usage. No redundant words or filler.

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

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

For a single-parameter read-only tool with no output schema, the description fully covers what the tool does, what it returns, and when to use it. There are no critical gaps given the low complexity.

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

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

Schema description coverage is 100%, and the parameter 'funnel_id' is described as 'The funnel public ID or internal ID'. The description's reference to 'this funnel' adds no new parameter-level meaning, so it does not exceed the schema's baseline.

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

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

The description uses a specific verb 'Get' and clearly identifies the resource ('list of questions for this funnel'), distinguishing it from sibling tools like get_form and list_forms. It also enumerates the return contents (question keys, types, descriptions, options), making the purpose unmistakable.

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

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

Explicitly states when to use this tool: 'Call this BEFORE check_fit or book_appointment'. This provides clear direction on the workflow context and differentiates it from related tools, offering an explicit alternative guidance.

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

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

Annotations already declare readOnlyHint=true and destructiveHint=false, so the safety profile is covered. The description adds value by specifying what the read returns (pending hot-lead count, criteria active, last update), which is non-obvious. It does not contradict annotations and aligns with the read-only nature.

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

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

A single front-loaded sentence that states the purpose and key return fields with no filler. It is efficient, though it could have used one clause to add usage guidance 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?

For a simple read tool with one parameter and no output schema, the description adequately explains the return values (pending hot-lead count, criteria status, last update). Since there is no output schema, the description rightly carries the burden of disclosing return contents. The main omission is a hint about when this state reads differ from form retrieval, but for a single-param read call this is 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 0%, so the description must compensate for the undocumented formId parameter. The description's reference to 'a form's' implicitly identifies formId as the target form, but it adds no additional meaning about the format or expectations of the parameter. Since there is only one self-explanatory parameter, this is acceptable but not exceptional.

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

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

The description names a specific verb ('Get'), a specific resource ('a form's lead-scoring state'), and even enumerates the exact data returned (pending hot-lead count, criteria active status, last criteria update). This clearly distinguishes it from siblings like get_form (which returns the form) and rescore_form_replies (which mutates scoring).

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. It does not mention when not to use it, nor does it name related tools like update_scoring_criteria or rescore_form_replies that an agent might confuse it with. Usage context is only implied through the resource name.

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 signal readOnlyHint=true and destructiveHint=false, so the safety profile is covered. The description adds no further behavioral context (e.g., whether the version might be unpublished, or response format), but for a trivial read operation this is acceptable. No contradiction with annotations.

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

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

The description is a single, front-loaded sentence with zero filler. It communicates the core purpose immediately and follows best practice for concise tool definitions.

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

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

For a single-parameter read with annotations and full schema coverage, the description is largely sufficient. However, it does not clarify how this differs from get_published_form_version, which is a notable sibling that could cause an agent to pick the wrong tool without additional context. A brief hint about 'any version, including unpublished' would complete it.

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

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

Schema description coverage is 100%: the only parameter 'id' is already described as 'The form version ID'. The description adds nothing beyond that, so it does not enrich the parameter meaning. Baseline 3 applies since the schema fully documents the parameter.

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

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

The description states a specific verb ('Get') and resource ('a specific form version') tied to the version ID parameter. It clearly distinguishes from siblings like get_form (presumably current) and get_published_form_version by emphasizing 'specific' version retrieval, leaving no ambiguity about the operation.

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

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

No guidance is given on when to use this tool instead of alternatives such as get_form or get_published_form_version. The description implies retrieval of any version but does not clarify the distinction (e.g., unpublished, historical versions), so an agent is left to infer use cases.

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

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

Annotations declare readOnlyHint=true and destructiveHint=false, covering the safety profile. The description adds no extra behavioral context (e.g., return format, error handling), but given the annotations, a baseline of 3 is appropriate.

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

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

A single, front-loaded sentence with no filler. Every word earns its place, making it highly concise 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?

For a simple read operation with one parameter and no output schema, the description is nearly sufficient. It implies the return value (the integration object) but does not explicitly state it. Given the simplicity, this is 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 0%, so the description must carry meaning. 'By ID' clarifies that the 'id' parameter uniquely identifies the integration, adding some value beyond the bare schema. However, it does not explain the ID format or type, so it only partially compensates.

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 'Get a single integration by ID' clearly states the action (get), the resource (integration), and the scope (single by ID). This distinguishes it from list_integrations (which lists) and get_connection (a different 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 provides no guidance on when to use this tool versus siblings like list_integrations or get_connection. There is no mention of use cases, 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 declare readOnlyHint=true, destructiveHint=false, and openWorldHint=false, so the agent knows it's a safe read operation. The description adds the scope to the 'active organization' and lists the exact fields returned, which goes beyond the annotations and clarifies what the agent can expect. There are no negative side effects or hidden behaviors to disclose.

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

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

The description is a single sentence with no filler. It front-loads the primary purpose and includes the essential field list in parentheses. Every word contributes to the meaning, making it highly efficient.

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

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

For a parameterless, read-only tool with no output schema, the description is complete. It states what the tool returns (logo, favicon, brand color) and scopes it to the active org. An agent can confidently invoke this without further clarification.

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

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

There are zero parameters, so the schema is trivially 100% covered. The baseline for 0 params is 4, and the description doesn't need to add any parameter detail because none exist. The description appropriately focuses on the output, making this a clean read-only call.

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

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

The description states a specific verb ('Get') and resource ('active organization's white-label branding'), and enumerates the specific elements returned (logo, favicon, brand color). This clearly distinguishes it from the sibling update_org_branding, which is the mutation counterpart.

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

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

The phrase 'active organization' implies this is tied to the current org context, which is useful guidance. It doesn't explicitly contrast with alternatives, but the sibling update_org_branding is an obvious counterpart, and the read-only nature is clear from the description and annotations. No explicit exclusions are needed for such a simple getter.

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

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

Annotations already declare readOnlyHint and destructiveHint, so the safety profile is covered. The description adds that the target is the active org and lists the returned fields, which is useful context. However, it does not disclose additional behaviors like response format, error conditions, or auth requirements, so it only modestly extends beyond annotations.

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

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

The description is a single, front-loaded sentence with no redundant wording. It conveys the verb, resource, and scope efficiently, earning its place without padding.

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

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

For a simple getter with no parameters and no output schema, the description sufficiently covers the return value by naming the fields (sender name, reply-to). It does not mention error cases or permission requirements, but given the trivial complexity, it is complete enough for an agent to invoke correctly.

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

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

The tool has zero parameters, so the baseline is 4. There is nothing for the description to elaborate on regarding parameter meaning, and the schema is complete by being empty.

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

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

The description states a specific verb ('Get'), a clear resource ('active org's white-label email config'), and enumerates the key fields returned (sender name, reply-to). This distinguishes it from sibling getters like get_org_branding or get_business_info, which target different configuration aspects.

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 retrieving email configuration, but it does not explicitly mention when not to use it or name alternatives (e.g., update_org_email_config for writes, get_org_branding for branding). Guidance is left to inference, which is acceptable for a simple getter but not explicit.

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

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

Annotations already declare readOnlyHint=true and destructiveHint=false, so safety is covered. The description adds the semantic detail that it returns the live published version respondents see, which is useful context beyond the annotations. However, it does not disclose behavior like what happens if no published version exists, but this is a minor gap given the read-only nature.

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

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

The description is a single, concise sentence that front-loads the core purpose and adds a parenthetical clarification. There is no filler or 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?

For a simple read operation with one parameter and no output schema, the description is adequately complete. It clearly defines what is returned and would be unambiguous for an agent. The only minor gap is not clarifying the distinction from get_form_version, but that is already addressed in purpose clarity.

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

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

The schema describes formId as 'The form ID' with 100% coverage, so the description appropriately does not add parameter details. The description adds no extra semantics, but the schema is sufficient for a single simple parameter, meeting the baseline of 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 action (get) and resource (latest published version of a form), and clarifies it's the 'live snapshot respondents see'. This distinguishes it from sibling tools like get_form_version (which likely retrieves a specific version) and get_form (which may retrieve the draft).

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 you need the live published version, but it does not explicitly name alternatives or specify when not to use it. Siblings like get_form_version and get_form are present, so explicit routing would improve clarity, but the implication is understandable.

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

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

Annotations already declare readOnlyHint=true and destructiveHint=false, so the description does not need to restate that. It adds value by naming the insight types (completion, drop-off, answer distributions), which is useful context beyond annotations, but it does not describe output format, pagination, or other behavioral nuances.

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

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

The description is a single sentence that front-loads the core action and resource, and enumerates the insight types without excess. Every word earns its place; no fluff or redundancy.

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

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

For a read-only tool with two parameters (one required, one optional) and no output schema, the description is adequate but does not specify the exact return format or how the insights are structured. Given its simplicity, a slightly richer description (e.g., output shape) would improve completeness, but it remains usable as-is.

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 mentions 'over a time range', which loosely maps to the timeRange parameter, but does not explain its enum values or default. It does not describe formId at all. Since schema coverage is 0%, the description should compensate, but parameter names and the enum are self-explanatory, so a baseline of 3 is reasonable.

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 'get' and the resource 'aggregate insights for a form's replies', and lists specific insight types (completion, drop-off, answer distributions). This distinguishes it from list_replies (raw data) and analytics_chat (conversational analytics) even without explicit sibling references.

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 aggregate insights, but does not explicitly state when to use this tool vs alternatives like list_replies or analytics_chat, nor does it mention prerequisites such as form existence or permission requirements. It provides no exclusionary guidance.

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

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

Annotations already declare readOnlyHint=true and destructiveHint=false, so safety is covered. The description adds value by noting that the response includes answers and scoring, which is not visible in the schema. It provides useful detail beyond the structured annotations without contradicting them.

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

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

The description is a single, concise sentence with no filler. It front-loads the core action and result, every word earns its place. Perfectly sized for a simple get tool.

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

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

For a one-parameter read-only tool with no output schema, the description is complete. It explains what the tool returns (answers and scoring), which is the key missing detail. Nothing essential is omitted; error handling and permissions are not critical given the simplicity and read-only annotation.

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% (the single 'id' parameter is described as 'The reply ID'). The description does not add any extra meaning about ID format, required pattern, or behavior for missing IDs, so it does not go beyond what the schema already provides. The baseline of 3 applies.

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

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

The description clearly states the tool fetches a single reply by ID and specifies that it includes answers and scoring. This distinguishes it from sibling tools like list_replies (multiple replies) and get_replies_insights (aggregate data), 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 implies usage (when you have a unique reply ID and need its details) but does not explicitly mention alternatives or when not to use it. There is no comparison to list_replies or other sibling tools, so guidance is only implicit rather than explicit.

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

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

Annotations already declare readOnlyHint=true and openWorldHint=true, so the safety profile is covered. The description adds the funnel-scoping and category filter behavior but doesn't disclose pagination or ordering beyond what annotations provide.

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

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

Two short sentences, front-loaded with the action, no wasted words. The optional category filter is clearly stated.

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

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

For a simple list tool with one required parameter and an optional filter, the description is adequate. It could mention return format or pagination, but given no output schema and low complexity, it's sufficiently complete.

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

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

Schema covers 100% of parameters with descriptions. The description's 'optionally filter by category' echoes the schema without adding new meaning, so the baseline of 3 is appropriate.

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

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

The description clearly states it retrieves a list of services or products for a specific funnel, with optional category filtering. The verb 'Get' and resource scope distinguish it from mutation tools, though it doesn't explicitly differentiate from the sibling tool search_services.

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?

Implied usage is when you need a business's services for a given funnel, optionally filtered by category. No explicit when-not or alternatives are mentioned, but the funnel-centric scope provides some 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?

The annotations already declare readOnlyHint=true and destructiveHint=false, so the tool is known to be a safe read operation. The description additionally explains that identity is derived from the OAuth token, which is a useful behavioral detail beyond the annotations. It does not contradict any annotations and provides relevant authentication 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 concise sentences. The first sentence front-loads the tool's output (ID, email, name, active organization), while the second explains the authentication source and lack of parameters. Every sentence carries meaningful information with zero waste, making it highly scannable.

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, parameterless, read-only getter with no output schema, the description is fully complete. It states what the tool returns, why no parameters are needed, and the authentication context. The annotations cover the safety profile, so nothing essential is missing for an agent to invoke the tool correctly.

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

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

The tool has zero parameters, and the schema description coverage is trivially 100%. The description explicitly states 'no parameters needed' and explains why (identity comes from the OAuth token). This goes beyond the empty schema by providing the rationale, which is exactly what an agent needs to know. A 5 is warranted given the clarity for a parameterless tool.

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

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

The description clearly states the tool's purpose: it retrieves the authenticated user's ID, email, name, and active organization. This is a specific verb (get) with a resource (user info) and explicit fields, making it easy to distinguish from other getter tools like get_business_info or get_org_branding.

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?

While the description does not explicitly name alternative tools or conditions, it makes usage obvious: it is for retrieving the authenticated user's identity and current organization. The note that identity comes from the OAuth token and that no parameters are needed clarifies exactly when this tool applies, leaving little ambiguity. A 4 is appropriate because it omits explicit 'use this when' guidance but the 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?

Annotations already declare readOnlyHint=true and destructiveHint=false, covering the safety profile. The description adds a useful behavioral note: it returns the extracted profile and directs to update_form for persistence, clarifying that this tool does not persist. It also mentions the purpose (marketplace discovery) as context. While it doesn't cover failure modes or network behavior, the combination of annotations and description offers sufficient behavioral transparency for a read-only extraction tool.

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

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

The description is a single, well-structured sentence that front-loads the main action and result, then adds the follow-up action. Every phrase earns its place: the verb, the resource, the purpose, the return, and the persistence instruction. There is no redundancy or filler.

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

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

For a tool with one parameter, no output schema, and annotations that already define safety, the description covers the core needs: what it does, what it returns, and how to proceed after. It lacks details on error conditions or URL requirements (e.g., must be publicly accessible), but those are reasonable gaps given the simplicity. The description is adequate for an agent to call it correctly in the intended marketplace-discovery 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?

The input schema has no description for the 'url' parameter (coverage 0%), so the description must compensate. It does so by explicitly stating the URL is the source from which to extract the profile ('from a website URL'). This gives the parameter clear semantic meaning beyond its format (uri). Though it doesn't specify constraints like validity or reachability, the description successfully clarifies the parameter's role.

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 ('Extract a business/agent profile') and the specific resource (a website URL), plus the purpose ('for marketplace discovery'). This distinguishes it from most sibling tools, though it does not explicitly contrast with similar tools like get_business_info or search_merchants. The verb 'extract' and resource are specific enough that an agent can infer its primary function.

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

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

The description implies a workflow by saying 'use update_form to persist it,' indicating this tool is the extraction step before persistence. It gives context (marketplace discovery) but does not explicitly state when NOT to use it or name alternative tools. The usage guidance is present but not exhaustive, so it earns a 3.

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

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

Annotations already declare readOnlyHint=true and destructiveHint=false, so the safety profile is covered. The description adds context that bases are scoped to a connection, which is useful, but it doesn't disclose other behaviors like pagination or result ordering, which the openWorldHint hints at.

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 with zero redundancy. It immediately conveys the action and scope without any filler, achieving optimal 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?

The description is sufficient for a simple listing operation but leaves gaps: no mention of output format, pagination, or any limits. Given the absence of an output schema and the openWorldHint indicating non-exhaustive results, an agent might need more detail to handle large result sets. However, for a basic list call, it's minimally 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?

The schema has one parameter, connectionId, with type string and no description. The tool description mentions 'a connection' but never explicitly explains that connectionId is the identifier for that connection. With 0% schema coverage, the description should compensate, but it only minimally implies the relationship without adding concrete 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 a specific verb 'List' and resource 'Airtable bases', with a scoping phrase 'available to a connection' that differentiates it from generic listing tools like list_connections or list_forms. It leaves no ambiguity about what the tool does.

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 is provided on when to use this tool versus other listing tools or any alternatives. There is no mention of prerequisites, exclusions, or conditions, leaving the agent to infer usage solely from the name and scope.

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

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

Annotations already declare readOnlyHint=true and destructiveHint=false. Description adds that the tool returns merchant counts and covers all marketplace categories, providing useful context beyond the annotations. No contradictions.

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

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

Two sentences, immediately states action and output, with a use-case pointer. No filler.

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

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

For a zero-parameter, read-only listing tool without an output schema, the description adequately covers purpose, output, and usage 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?

Tool takes no parameters; schema coverage is vacuous. Description naturally doesn't need to explain parameters. Baseline 4 applies.

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

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

The description uses a specific verb ('list') with a clear resource ('service categories') and scope ('all available on the Dashform marketplace'), and adds output detail ('merchant counts'). It clearly distinguishes from related search tools by positioning it as a precursor to searching.

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?

States when to use: 'before searching' to understand available service types. Does not explicitly name alternative tools, but the guidance is clear for a simple category listing.

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

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

Annotations already declare readOnlyHint=true and destructiveHint=false, so the safety profile is established. The description adds useful context about the scope (active organization) and filtering capability, but does not disclose potential behavioral traits such as pagination, ordering, or rate limits. Since annotations cover the core safety aspects, 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?

The description is two sentences long with zero filler. It front-loads the main action and scope, then adds the optional filtering detail. Every word earns its place, making it highly concise 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?

For a simple list tool with one optional parameter and no output schema, the description covers the essential elements: what is listed, in what scope, and optional filtering. It includes provider examples for clarity. There is no mention of return format or pagination, but these are not strictly necessary for such a straightforward tool. The description is sufficiently complete for an agent to call it correctly.

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

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

The input schema has one optional 'provider' parameter with an enum list, and schema description coverage is 0% (the description does not list parameters explicitly). However, the description does mention 'Optionally filter by provider', which conveys that the parameter is optional and its purpose. This adds some meaning beyond the enum, but not much; the schema already defines the values. Given the simplicity of the parameter, a baseline of 3 is appropriate.

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

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

The description clearly states the tool's purpose: listing integration connections in the active organization, with optional provider filtering. It uses a specific verb and resource, and includes examples of provider types. However, it does not explicitly differentiate from the sibling tool 'list_integrations', which could be similar in purpose, so it lacks explicit sibling differentiation.

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

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

The description implies usage: use this to list integration connections in the active organization, optionally filtered by provider. However, it does not provide explicit guidance on when to choose this tool over alternatives like 'get_connection' or 'list_integrations', nor does it mention any exclusions or prerequisites. The context is clear but not prescriptive.

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

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

Annotations already declare readOnlyHint=true and destructiveHint=false, so the read-only nature is covered. The description adds the scope ('active organization') and output concept ('status'), which is useful but minimal. It does not mention pagination, rate limits, or error conditions, though for a zero-parameter list tool these may be unnecessary.

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

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

A single, well-structured sentence that delivers the purpose and key scope without redundancy. The verb is first, and every word adds value. No fluff or unnecessary 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 list operation with no parameters and no output schema, the description provides all essential context: what is listed (custom domains) and the organization scope. Annotations cover read-only behavior. Nothing critical is missing for a correct invocation.

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

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

There are no parameters, so the schema coverage is effectively 100% (vacuously). The baseline for 0 params is 4, and the description correctly avoids inventing non-existent parameters. It does not need to explain parameters that do not exist.

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 ('List'), the resource ('custom domains'), and the scope ('active organization'), along with the additional detail that status is included. It is immediately distinguishable from sibling tools like add_custom_domain or verify_custom_domain, which perform different 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 usage (when you need to see domain statuses) but provides no explicit guidance on when to prefer this over alternatives, such as verify_custom_domain or set_custom_domain_default_form. No exclusions or alternative suggestions are given, leaving the agent to infer from the name and purpose.

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

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

Annotations already declare readOnlyHint=true and destructiveHint=false, so the description doesn't need to restate safety. It adds that results include status and share/edit URLs, which is useful behavioral context beyond a simple list. However, it doesn't disclose pagination details (cursor-based, max limit) which are in schema but not description. With strong annotations, a 3 is appropriate.

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, efficiently packed with purpose and capabilities. No fluff or repetition. Each clause adds value: listing forms, active org scope, status/URLs, and feature summary.

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

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

For a read-only list tool with 5 parameters (0 required), no output schema, and a simple result (forms with status and URLs), the description covers scope and capabilities but not default behaviors like default sort. Given that output schema is absent, it should mention the response format, but 'with status and share/edit URLs' implies the shape. Adequate for most agents, but could state defaults.

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

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

Schema coverage is only 40% (only cursor and search have descriptions; limit, sortBy, sortOrder lack descriptions). The description adds meaning by mentioning search, sort, and pagination, but doesn't explain specific parameter semantics like default sort order or allowed sort fields. Since it partly compensates for the missing schema descriptions, a 4 is reasonable.

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

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

The description clearly states the tool lists forms in the active organization, with status and share/edit URLs, and mentions search, sort, and pagination. It distinguishes itself from related tools like get_form (singular fetch) and list_replies (replies) by focusing on form listing with specific output details.

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

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

The description implies it should be used to browse or search forms in the active org, and mentions pagination for large result sets. It doesn't explicitly exclude alternatives like get_form for single-form retrieval, but the context of 'list' with pagination makes it clear. No when-not-to-use guidance, but context is sufficient for common cases.

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

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

Annotations already declare readOnlyHint=true and openWorldHint=true, so the safe-read nature is established. The description adds value by clarifying the scope ('available to a connection'), but it does not disclose output format, pagination, or ordering behavior. For a tool with annotation coverage, this is adequate but minimal.

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, tight sentence that front-loads the verb and resource. There is no wasted wording, though it could include a bit more structure (e.g., mentioning the parameter) without losing 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?

For a tool with only one parameter and no output schema, the description fails to cover what the response will contain or how to properly supply the connection ID. Given the large sibling list, a little more context (e.g., return type) would make it 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?

The schema has one parameter (connectionId) with 0% description coverage. The tool description only hints at the parameter via 'available to a connection' but does not explain what connectionId is, its format, or how to obtain it. This is insufficient given the lack of schema documentation.

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

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

The description clearly states the action (List), the resource (HubSpot contact properties), and the scope (available to a connection). It is specific enough to distinguish from other list tools like list_connections or list_forms, even without naming a sibling.

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

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

No guidance is provided on when to use this tool versus alternatives. The description does not mention any exclusions, prerequisites, or sibling tools to consider. While the name implies usage for HubSpot contact properties, there is no explicit direction.

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

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

Annotations already declare the tool as read-only and non-destructive, so the description is not the sole carrier of safety profile. It adds some context by specifying 'recent delivery events' and 'for an integration', which narrows the scope beyond the annotations. However, it omits behavioral details like pagination, ordering, or the meaning of 'recent' (e.g., time window). Since annotations cover the basics and the description adds minimal but useful context, a score of 3 is appropriate.

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, efficient sentence that gets straight to the point. It is not verbose and contains no filler. However, it is slightly under-specified for a tool with two parameters and no output schema, so it doesn't fully earn its place in terms of informative value. Still, for conciseness alone, it is well-structured and front-loaded, warranting a 4.

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

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

The tool has no output schema and low schema coverage, so the description must provide enough contextual detail for an agent to call it correctly. It lacks any information about what 'delivery events' are, what 'recent' means, how `limit` affects results, or what the response contains. This is inadequate for a tool with parameters that are not self-explanatory. A score of 2 reflects the substantial gaps.

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

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

Schema description coverage is 0%, so the description must compensate by explaining parameters. It fails to do so: neither `integrationId` nor `limit` is elaborated. The description only repeats the concept of listing events, adding no meaning beyond the property names themselves. With zero additional parameter semantics, this is a score of 1.

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 ('List') and the resource ('recent delivery events for an integration'), which is specific and unambiguous. It differentiates from siblings like `replay_integration_event` by focusing on listing rather than replaying, though it doesn't explicitly name alternatives. This aligns with a score of 4: clear but no explicit sibling differentiation.

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

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

The description provides no guidance on when to use this tool versus alternatives. It does not mention any context, exclusions, or trade-offs (e.g., when to use `get_integration` or `replay_integration_event`). With no usage guidance at all, this meets the rubric for a score of 2.

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

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

Annotations already declare readOnlyHint=true and destructiveHint=false, covering the safety profile. The description adds the scoping detail 'on a form', which is useful context, but nothing else—no mention of return format, pagination, or potential rate limits. With annotations mitigating the need for safety disclosure, a score of 3 reflects the modest additional value provided.

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, direct sentence with zero wasted words. It is appropriately sized for the tool's simplicity and front-loads the essential action and scope. No unnecessary details or repetition.

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

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

For a simple read-only list operation with one required parameter and no output schema, the description is largely sufficient. It tells what the tool does and the scope, and the annotations cover safety. The only gap is the lack of usage guidance (when to use vs. alternatives), but that is a minor omission given the low complexity.

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

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

Schema description coverage is 0%, so the description must compensate for the undocumented parameter. The phrase 'configured on a form' implicitly explains that formId refers to the form whose integrations are listed, and the parameter name is self-explanatory. This provides enough meaning for a single obvious parameter, though it does not explicitly describe formatting or constraints beyond the schema's type string.

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

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

The description clearly states the verb 'List' and the resource 'integrations configured on a form', which identifies the operation and its scope. While it doesn't explicitly differentiate from sibling tools like get_integration or list_integration_events, the plural 'list' and the contextual 'on a form' make 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 no guidance on when to use this tool versus alternatives such as list_connections or get_integration. It does not mention any conditions, prerequisites, or exclude cases, leaving the agent to infer from the name alone. This is a minimal but acceptable gap for a simple read operation.

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

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

Annotations already declare readOnlyHint=true and destructiveHint=false, so the read-only nature is covered. The description adds the connection scoping, which is useful, but does not disclose any further behavioral details (e.g., pagination, result limits, or error cases). Given the low complexity and existing annotations, a 3 is appropriate.

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

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

The description is a single sentence with zero waste, directly stating the operation and scope. It is optimally concise and 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 tool with one parameter and no output schema, the description is minimal but covers the basic action. However, it lacks crucial details about the connectionId parameter and the expected return format, which an agent would need to call it correctly in varied contexts.

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

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

Schema description coverage is 0% and the description does not elaborate on the connectionId parameter beyond mentioning 'available to a connection.' It does not explain how to obtain or format connectionId, leaving the agent with minimal guidance for the only required parameter.

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

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

The description uses a specific verb (List) and resource (Mailchimp audiences) and scopes it 'available to a connection,' which clearly distinguishes it from sibling tools like list_airtable_bases or list_slack_channels. The purpose is immediately obvious.

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 Mailchimp audiences but does not explicitly state when to use this tool versus alternatives, nor does it mention any prerequisites or exclusions. The scope 'available to a connection' gives some context, but no explicit routing 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?

Annotations already declare readOnlyHint=true and destructiveHint=false, so the read-only nature is covered. The description adds critical context beyond annotations: that results are 'per-form' and scoped to 'the active organization'. This clarifies the output granularity and organizational scope, which are not in the annotations.

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

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

The description is a single, front-loaded sentence with no filler. It conveys the essential information efficiently, exactly stating the action and scope. No wasted words.

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

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

For a simple list tool with no parameters and no output schema, the description provides sufficient information: it lists per-form hot-lead counts for the active organization. There is no missing information that an agent would need to invoke it correctly, given the tool's simplicity.

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

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

There are zero parameters and schema coverage is 100% (vacuously). According to the rubric, 0 params gets a baseline of 4. The description adds value by specifying what the output represents (hot-lead counts per form), even though there are no parameters to explain.

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

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

The description clearly states the verb 'List' and the resource 'per-form hot-lead counts' with the scope 'across the active organization'. It precisely identifies what the tool returns and distinguishes it from sibling tools that focus on other domains (e.g., forms, integrations). No ambiguity.

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

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

The description implies usage: an agent would call this when needing hot-lead counts per form for the active organization. However, it does not explicitly state when to use it over alternatives or provide any exclusions. Since there are no directly similar siblings, the guidance is implied rather than explicit.

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

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

Annotations already declare readOnlyHint=true and destructiveHint=false, so the safety profile is clear. The description adds the detail that the tool returns the user's role in each organization, which is useful context. However, it does not describe the output format or any other behavioral traits beyond what the purpose implies. With annotations covering the read-only nature, a 3 is appropriate.

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

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

The description is two sentences with no filler. It front-loads the core purpose and then provides a pointer to the relevant sibling tool. Every word earns its place.

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

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

For a simple read-only list operation with zero parameters and no output schema, the description is fully adequate. It covers what is returned (role) and how to proceed (switch_active_org), making it complete for an agent to call 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?

There are zero parameters, so the schema is empty and requires no explanation. The baseline of 4 applies because there is nothing to add; the description correctly does not invent irrelevant parameter information.

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

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

The description clearly states the tool 'lists all organizations the authenticated user belongs to, with their role in each.' It names the resource (organizations) and the scope (authenticated user's memberships), and it distinguishes itself from the sibling tool switch_active_org by explicitly stating its purpose and mentioning the alternative for changing active org.

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

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

The description explicitly tells the agent when to use this tool ('List all organizations...') and directs it to the sibling tool for the next step: 'Use switch_active_org to change which one MCP acts on.' This provides clear context and an alternative, leaving no ambiguity about which tool to pick.

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

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

Annotations already declare readOnlyHint=true and destructiveHint=false, covering the safety profile. The description adds value beyond that by disclosing the paginated nature of the operation and the type of data returned (respondent data, status, scoring verdict). This gives the agent a clearer picture of behavior, though it does not mention rate limits or exact error conditions. Overall, it adds meaningful context beyond the annotations.

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

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

The description is a single, well-structured sentence. It front-loads the primary action ('List replies for a form') and then adds the essential qualifier '(paginated)' and the return content. No filler words or redundant information. It is a model of conciseness while still conveying necessary 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?

The tool is a paginated list operation with no output schema. The description covers the purpose and high-level return data, but it lacks usage guidance (when to prefer this over siblings) and does not explain the pagination mechanism beyond the word 'paginated'. The schema partially fills gaps (e.g., cursor description), but overall the description is not fully complete for an agent to seamlessly select and call it in all contexts.

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 67%, with formId and cursor described in the schema, but limit lacks a description. The tool description itself adds no parameter information, leaving the agent to rely on the schema. Since coverage is moderate, the description does not need to compensate fully, but it could have clarified the limit parameter or how pagination works. This yields a baseline score of 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 'List replies for a form' with a specific verb and resource, and adds that it is paginated and returns respondent data, status, and scoring verdict. It is not a tautology and gives a precise idea of the tool's function. However, it does not explicitly differentiate from sibling tools like get_reply or get_replies_insights, so it misses that extra distinction.

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

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

The description provides no guidance on when to use this tool versus alternatives. It does not mention any conditions, exclusions, or refer to sibling tools such as get_reply for single replies or get_replies_insights for analytics. There is no context about the intended use case or when not to use it, leaving the agent to infer from the name alone.

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

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

The annotations already declare readOnlyHint=true and destructiveHint=false, so the description does not need to repeat safety. However, the description adds only the 'available to a connection' scoping, which is already implicit in the connectionId parameter. It does not disclose return format, pagination behavior, rate limits, or whether the list is exhaustive, so with annotations present the added value is minimal.

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 filler or redundant information. It is efficient and appropriately sized for a simple list operation.

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

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

Given the tool has only one parameter and no output schema, the description should at least hint at the return value or provide usage context. It does neither, leaving the agent uncertain about what the response contains or how to interpret the results. For a simple tool this is a notable gap.

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

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

Schema description coverage is 0%, so the description must compensate for explaining the connectionId parameter. It only mentions 'connection' vaguely without detailing where the connectionId comes from, what format it takes, or how it relates to the Slack workspace. This leaves the agent underspecified for constructing a valid call.

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

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

The description states a clear verb ('List') and resource ('Slack channels') and scopes it to 'a connection', which helps distinguish it from sibling list tools targeting other systems like airtable or mailchimp. It is specific enough for an agent to understand the basic operation, though it doesn't explicitly clarify what 'available' means (e.g., public only, or includes private channels).

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 is given on when to use this tool versus alternatives like list_airtable_bases or list_mailchimp_audiences. There is no mention of prerequisites, typical use cases, or exclusions, leaving the agent to infer context solely from the name and description.

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

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

Annotations already declare readOnlyHint=true and destructiveHint=false, so the read-only nature is covered. The description adds no further behavioral context (e.g., pagination, response format, or authentication), but it does not contradict the annotations. Given the annotation coverage, a neutral score is appropriate.

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 that front-loads the verb and resource. It contains no unnecessary words or filler, making it highly efficient for an agent to parse.

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

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

For a simple read-only list operation with one parameter and no output schema, the description adequately conveys what the tool does and what input it needs. It is sufficiently complete for an agent to invoke it correctly, though it could optionally mention the return type or typical usage 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 description coverage is 0%, so the description must compensate. It ties the single parameter formId to the concept of 'a form', clarifying that it identifies the form whose subscriptions are listed. This adds essential meaning beyond the bare schema definition, though it doesn't specify where to obtain the ID or any constraints.

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 ('List'), the specific resource ('Zapier webhook subscriptions'), and the scope ('for a form'). It distinguishes this tool from generic integration-listing tools like list_integrations by focusing on webhook subscriptions, making its 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 implies usage context: it is for a specific form of Zapier subscriptions, so an agent would use it when needing those subscriptions for a given formId. However, it does not explicitly mention alternatives or when not to use it, leaving the routing decision to the agent's inference from sibling names.

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 idempotentHint=true, destructiveHint=false, and readOnlyHint=false. The description adds the clarification that 'actioned' means 'followed up on', which gives context to the state change. However, it does not disclose anything beyond that; the annotation coverage reduces the need for extensive behavioral disclosure.

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

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

The description is a single sentence that is direct and free of extraneous content. Every word serves a purpose, and the core action is front-loaded.

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

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

For a simple single-parameter mutation tool with no output schema, the description is adequate. It clearly states the action, and the parameter is fully documented in the schema. It could optionally mention that the operation is idempotent or that it sets rather than toggles the actioned status, but the idempotentHint annotation already covers this, so no critical information is missing.

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

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

Schema coverage is 100% and the 'id' parameter already has a description ('The reply ID'). The tool description adds no additional meaning or usage details for the parameter, so it does not exceed the baseline expected when schema is complete.

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

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

The description uses a specific verb ('Mark') with a clear resource ('a reply') and the target state ('actioned (followed up on)'). It distinguishes this from sibling tools like delete_reply or get_reply by describing a state-change operation rather than a retrieval or deletion.

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

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

The description does not explicitly state when to use this tool versus alternatives, nor does it mention exclusions or prerequisites. The purpose implies it should be used when a reply has been followed upon, but there is no direct guidance such as 'use this instead of deleting' or 'only for replies with pending follow-up'.

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 idempotentHint=true, destructiveHint=false, and readOnlyHint=false, so the safety profile is covered. The description adds that it returns the updated reply, but does not elaborate on what 'reset' does (e.g., whether it clears the override and reverts to auto-scoring). Some extra context about the effect of reset would improve transparency, but no contradictions exist.

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

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

A single clear sentence with no filler. The essential action and return value are stated efficiently, making it easy to scan quickly.

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

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

The description covers the core function and return value but omits details about the effect of reset and prerequisites (if any). Given the tool has a oneOf action parameter and no output schema, a bit more context about the difference between set and reset would make the tool more self-contained for an agent.

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

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

The schema has descriptions for only the id parameter (50% coverage), leaving the complex action parameter undocumented. The description says 'set or reset' which mirrors the schema's const values but adds no additional meaning about the reason field, the enumeration of verdicts (already in schema), or the differences between set and reset. With low coverage, the description should compensate but does not.

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

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

The description states a specific verb ('set or reset'), a clear resource ('reply's lead verdict'), and enumerates the possible verdict values (hot/warm/cold). It also distinguishes itself from read-only siblings like get_reply or list_replies by emphasizing the manual override 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 word 'Manually' implies human intervention rather than automatic scoring, but the description does not explicitly contrast it with alternative tools like rescore_form_replies or mark_actioned. There is no when-to-use or when-not-to-use guidance, though the purpose is clear enough to avoid basic misuse.

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 define readOnlyHint as false and destructiveHint as false. The description adds that it creates a 'new live version', implying it does not destroy the previous version but it does not disclose potential side effects like replacing the current live version or requiring specific permissions. With annotations covering the safety profile, 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?

A single, concise sentence that front-loads the core action and purpose. It does not waste words and delivers the key information efficiently.

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 mutation tool with one parameter and no output schema, the description gives enough to understand what it does and when it is needed. It does not mention edge cases (e.g., form must be valid, what happens to previous version), but these are not critical for correct invocation. The context from annotations and schema make it sufficiently complete.

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

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

Schema coverage is 100% — the `id` parameter is already documented as 'The form ID to publish'. The description does not add additional meaning or constraints for the parameter beyond what the schema provides, so it stays at 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 action ('Publish') and the resource ('form's current draft as a new live version'), and distinguishes it from related tools like update_form (edits draft) and get_published_form_version (reads published). The additional context that it is required before a form can receive replies reinforces its unique 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 provides a clear usage condition ('Required before a form can receive replies'), which tells the agent when to invoke it. It does not explicitly name alternatives or exclusions, but the sibling list implies alternatives like update_form or get_published_form_version. This is adequate but not exhaustive.

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

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

Annotations already declare readOnlyHint=true and destructiveHint=false, and the description's verb 'check' aligns with a read-only operation. The description adds that it checks a 'backfill backlog,' which is a specific behavioral detail not in the annotations, but it does not explain what the result indicates or how it affects reconnection. With annotations covering the safety profile, the description provides modest additional 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 sentence, extremely concise with no unnecessary words. It front-loads the primary action and context. While it could be expanded with useful details, the structure is efficient and all content serves a purpose.

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

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

Given the low schema coverage and absence of an output schema, the description must carry the burden of explaining what 'backfill backlog' and 'quota' mean, and what the precheck result implies. It does not clarify these terms or the expected return value. An agent cannot infer whether the tool returns a boolean, a count, or a detailed report, making the description insufficient for correct invocation.

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

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

Schema description coverage is 0%, and the only parameter (connectionId) has no schema description. The description mentions 'for a connection' which implicitly maps to connectionId, but it does not explain what a connectionId is, its format, or how it is used. With no schema details, the description fails to compensate for the parameter's semantics, leaving the agent to guess.

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

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

The description states a specific verb ('check') and resource ('backfill backlog for a connection') and provides the context 'before reconnecting it.' This makes the primary purpose clear, though it does not explicitly differentiate from sibling tools like get_connection or revoke_connection. The wording is specific enough to avoid being a tautology.

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

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

The phrase 'before reconnecting it' gives a clear temporal context for when this tool should be used. However, it does not mention alternatives (e.g., get_connection) or conditions under which it should not be used. The guidance is present but minimal, leaving the agent to infer that this is a precheck rather than an action.

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

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

Annotations already declare readOnlyHint=true and destructiveHint=false, so the safety profile is covered. The description adds the 'single-shot' behavior, which is a useful trait beyond the schema (implying no streaming or multi-step interaction). However, it does not explain the openWorldHint or any other behavioral nuances. The bar is lower because annotations carry the safety information, but the description could have added more context about what 'AI-refine' entails (e.g., determinism, dependency on external services). No contradiction with annotations.

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

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

The description is a single, front-loaded sentence that conveys the core purpose and output. It is concise with no wasted words. However, it is so short that it sacrifices behavioral and parameter details, but that is more a completeness issue. As a concise statement, it is efficient. It could be slightly longer to include key usage or parameter context, but the structure is good.

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 two parameters and no output schema, the description should provide enough context to call it correctly. It names the parameters indirectly but does not specify their nature or expected values. The output is described as 'refined prompt text', but there is no indication of whether that is a plain string, a structured object, or something else. The description is not complete enough for an agent to confidently invoke it without further inference.

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

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

Schema description coverage is 0%, so the description must compensate. It mentions 'form-building prompt' and 'funnel type' which map to 'prompt' and 'formType' respectively, but it does not explain what 'prompt' specifically is (the input prompt to be refined) or the meaning of 'structured' vs 'dynamic' form types. The description does not add any detail about parameter formats, constraints, or examples. This is a significant gap given zero 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's function: 'AI-refine a form-building prompt for the given funnel type.' The verb 'refine' is specific, the resource is 'form-building prompt', and it mentions the input parameter 'funnel type'. It also notes the return value ('Returns the refined prompt text'). However, it does not explicitly differentiate from siblings like create_form or chat_form_editor, though the purpose is distinct enough. It would be a 5 if it named a sibling or exclusion.

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 no guidance on when to use this tool versus alternatives. It does not mention any prerequisites, when to choose it over other form-related tools (e.g., create_form, chat_form_editor), or any context that would help an agent decide to invoke it. The only hint is 'for the given funnel type', which is more about the input than usage context. No exclusions or alternative references are provided.

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

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

Annotations already declare destructiveHint=true and readOnlyHint=false, so the description doesn't need to restate that this is a destructive operation. It does add value by requiring confirm: true to proceed, which is an important behavioral guardrail, and it discloses the permission requirement (Owner/admin only). This goes beyond the annotations without contradicting them.

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

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

The description is two sentences with no filler. It front-loads the purpose, then adds permission and a required confirmation step. Every word earns its place—no redundant phrasing or 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?

For a simple mutation tool with 2 parameters and no output schema, the description covers the essential context: what action is performed, on which scope, permission requirements, and the safety confirm flag. It doesn't mention irreversibility or potential side effects, but destructiveHint and the confirm flag already signal that. Given the simplicity, this is nearly complete; the only missing piece is a note about whether the domain must be disassociated first, which is an edge case.

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

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

Schema coverage is 50%: only 'confirm' has a description ('Must be true to remove'). The description reinforces this by saying 'Pass confirm: true to proceed' but does not explain what 'id' represents beyond implying it's the custom domain identifier. For a low-coverage schema, the description should compensate more, e.g., clarifying that 'id' is the domain's unique identifier from list_custom_domains. It adds some meaning but not enough to fully bridge the gap.

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

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

The description states a specific action ('Remove'), the resource ('custom domain'), and scope ('from the active org'), plus permission ('Owner/admin only'). This clearly distinguishes it from sibling tools like add_custom_domain, list_custom_domains, and verify_custom_domain, which have different purposes.

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

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

The description clearly implies when to use the tool (when you want to remove a custom domain) and mentions a precondition (Owner/admin only), but it does not explicitly contrast with alternatives or state when not to use it. For example, it doesn't say 'use set_custom_domain_default_form to change the default instead.' This leaves some ambiguity for an agent choosing among related domain 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 declare readOnlyHint=false and destructiveHint=false, indicating a non-read-only, non-destructive mutation. The description adds no extra behavioral context—it does not disclose side effects (e.g., whether delivery is retried immediately, impacts on rate limits, or whether the event's state changes). With annotations present, the bar is lower, but the description still adds no value beyond the annotations.

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

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

The description is a single concise sentence that front-loads the core action and target. Every word earns its place, with no unnecessary elaboration.

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

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

For a single-parameter tool with no output schema, the description still leaves critical gaps: it does not explain how to identify a failed or past event, what 're-enqueue' means operationally, or any consequences. An agent cannot confidently call this tool without additional context (e.g., from list_integration_events or prior knowledge). Given the openWorldHint and mutation nature, more completeness is expected.

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

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

Schema coverage is 0% (the description does not explicitly describe the eventId parameter). The description refers to a 'failed or past integration delivery event' which indirectly implies eventId identifies such an event, but it does not explain the format or how to obtain a valid eventId (likely from list_integration_events). Since the description must compensate for the lack of schema documentation, this is insufficient.

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

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

The description uses the specific verb 're-enqueue' and names the resource as 'a failed or past integration delivery event', which clearly distinguishes this from listing events (list_integration_events) or creating/toggling integrations. The action is unambiguous and the scope 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?

No guidance is provided on when to use this tool versus alternatives. It does not reference list_integration_events (which would be the natural source for event IDs) or explain under what circumstances a re-enqueue is appropriate. The phrase 'failed or past' hints at usage but no explicit conditions or exclusions are given.

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

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

Annotations already indicate readOnlyHint=false and destructiveHint=false, so the description doesn't need to repeat that this is a mutation. It adds that this is a re-run operation and that it returns a count, which is useful. However, it does not describe other behavioral aspects like whether prior scores are overwritten, if the operation is asynchronous, or if any prerequisites (e.g., AI scoring must be enabled) exist. This goes slightly beyond what annotations cover, but only marginally.

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, compact sentence that states the action and return value with no unnecessary words. It is front-loaded with the key verb and resource. Every word contributes to understanding the tool's 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?

The tool has only one parameter and no output schema, so the description is expected to cover the essentials. It does state the action and return value. However, it omits details about side effects on existing scores, potential delays or async behavior, and any related setup (e.g., whether scoring criteria must be predefined). These gaps leave an agent with some uncertainty about the full impact of calling this tool.

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

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

The schema provides no description for formId (coverage 0%), so the description bears the burden. The description implies that formId identifies the form whose replies are to be rescored ('across a form's replies'), giving basic semantic meaning. However, it does not explain the format of formId or how to obtain it. This is a partial compensation for the missing schema description, but not exhaustive.

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

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

The description states a specific action ('Re-run AI lead scoring') and the resource ('across a form's replies'), which clearly identifies the tool's purpose. It also mentions the return value ('Returns the number marked for scoring'). It doesn't explicitly differentiate from siblings like get_form_scoring_state or update_scoring_criteria, but the verb 're-run' and the focus on replies make it distinct enough.

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 conveys the primary use case: when an agent needs to trigger AI lead scoring again for a form's replies. It gives clear context for when to use it, but it does not mention when not to use it or point to alternatives such as override_verdict or update_scoring_criteria. Since it provides clear context without exclusions, it earns a 4.

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

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

Annotations already declare destructiveHint=true, but the description adds the specific effect 'stops future deliveries' and the mandatory confirmation flag. It does not explain whether the revocation is reversible, what happens to existing data, or whether idempotentHint (true) affects the flow. It adds some value beyond annotations but leaves significant behavior undisclosed.

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

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

The description is two sentences long and front-loads the core action and effect. It is genuinely concise with no filler, but it sacrifices necessary detail. The structure is appropriate for the simplicity of the tool, though it could be slightly expanded without losing conciseness.

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

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

Given it is a destructive operation with 3 parameters (only 1 described), no output schema, and no usage alternatives, the description is incomplete. It omits the origin/format of 'id', valid values for 'reason', and the full consequences of revocation. An agent would need to infer or guess critical details, making this inadequate for safe invocation.

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

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

Schema coverage is low (33%)—only 'confirm' has a description ('Must be true to revoke'), and the tool description merely repeats that as 'Pass confirm: true to proceed.' It adds no meaning for 'id' (what constitutes a valid connection ID) or 'reason' (allowed values or purpose). With such low coverage, the description fails to compensate.

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 (revoke) and the resource (connection) along with the immediate effect (stops future deliveries). This distinguishes it from delete_connection, which would imply removal, and from toggle_integration, which implies a state flip. 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?

There is no guidance on when to use revoke versus alternatives like delete_connection or toggle_integration, nor any mention of prerequisites (e.g., must have an active connection). The only usage hint (pass confirm: true) is an invocation requirement, not a selection criterion.

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

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

The annotations already reveal it's a safe read-only operation (readOnlyHint=true, destructiveHint=false). The description adds behavioral insight by stating that each result includes a funnel_id that can be used with specific tools, which goes beyond both the schema and annotations. It doesn't mention pagination or ordering, but the limit parameter is documented in the schema.

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

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

The description is two sentences, front-loaded with the core purpose, and the second sentence adds the key downstream linkage without fluff. Every phrase earns its place.

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

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

For a simple search tool with complete schema annotations and an open-world hint, the description covers the core functionality, filtering options, and the critical funnel_id output for downstream integration. It adequately prepares an agent to invoke search and chain it with other 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 all parameters (limit, query, category, location) are already well-documented with examples and references to list_categories. The description's mention of filtering by category, location, or keyword adds no new detail beyond the schema, so baseline 3 is appropriate.

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

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

The description clearly states the tool's function as searching for businesses and service providers on the Dashform marketplace, using a specific verb ('Search') and resource (merchants). It distinguishes from sibling tools like search_services and search_photos by focusing on merchants and literally mentions the funnel_id for downstream use.

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 for when to use the tool: to find merchants and obtain funnel_ids for downstream tools like get_business_info, get_services, check_fit, and book_appointment. It doesn't explicitly list when-not-to-use or name alternative tools like search_services, but the downstream chain implies its role.

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

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

Annotations already declare readOnlyHint=true and openWorldHint=true, so the safety profile is covered. The description adds that it searches Pexels and the intended usage domain, but provides no additional behavioral details like pagination limits, authentication requirements, or response format. With annotations covering the baseline, a 3 is appropriate—some value added 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?

The description is a single, focused sentence with no filler. It front-loads the key action and context, and every word adds value. Perfectly concise and 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?

With 3 parameters, no output schema, and no parameter descriptions in the schema, the description alone must convey sufficient operational detail. It states the tool's purpose but omits response shape, pagination semantics, or any Pexels-specific constraints (e.g., licensing, orientation). The description is too sparse for an agent to fully understand what will be returned and how to use the pagination parameters 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 0%, so the description must compensate for explaining parameters. It only mentions 'background photos' which hints at what 'query' should contain, but does not explain 'pageSize' or 'pageIndex' beyond their schema defaults. The description adds minimal semantic meaning to the parameters, failing to compensate for the 0% coverage.

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

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

The description clearly states the action (search), the resource (Pexels for background photos), and gives concrete use cases (welcome/end screens, questions). This distinguishes it from sibling tools like search_videos or search_services, making the purpose immediately clear.

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

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

The description provides clear context for when to use the tool (when background photos are needed for screens/questions). However, it does not explicitly mention when not to use it or point to alternatives like search_videos; this is only implied. Lacks explicit exclusions or sibling guidance, so not a 5.

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

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

The description adds value beyond the readOnlyHint and destructiveHint annotations by disclosing that each result includes the provider funnel_id for booking, giving insight into the return payload. It does not contradict annotations and provides meaningful context about the tool's output.

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, concise, and front-loaded with the core action. Every sentence adds value: the first states the tool's purpose, and the second explains the searchable filters and output detail. No wasted words.

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

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

For a search tool with no required parameters and no output schema, the description covers the essential scope ('across all marketplace merchants') and output characteristic (provider funnel_id). It does not mention pagination or result sorting, but the schema's limit parameter covers pagination. It is slightly incomplete for a tool with no output schema, but sufficient for a straightforward search operation.

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

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

Schema description coverage is 100%, so the schema already documents all six parameters. The description mentions filters for name, category, price range, and location, which mirror the existing parameter descriptions, adding no new semantic detail beyond what the schema provides. This aligns with the baseline score of 3 for high coverage.

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

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

The description clearly states the tool's function: 'Search for specific services across all marketplace merchants.' It uses a specific verb ('search') and resource ('services'), and distinguishes itself from sibling tools like search_merchants and search_photos by focusing on services and mentioning the provider funnel_id.

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 context by listing search dimensions (name, category, price range, location) and stating it covers 'all marketplace merchants,' which differentiates it from merchant-specific searches. However, it does not explicitly mention when to use this tool over alternatives like get_services or list_categories, so it falls short of a 5.

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

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

Annotations already cover the safety profile (readOnlyHint=true, destructiveHint=false, openWorldHint=true). The description adds that the tool queries an external service (Pexels) and targets a specific content category, which is useful context. However, it does not disclose any additional behavioral traits such as pagination behavior, result format, or potential latency, so it adds modest value beyond the annotations.

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

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

The description is a single, front-loaded sentence that states the action and purpose with minimal waste. It includes concrete examples to clarify the type of videos, making it both concise and informative without superfluous text.

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

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

The tool is simple, but the description is incomplete for an agent. It does not explain the parameters (query, pageSize, pageIndex) despite the schema having zero coverage, and it does not mention the structure of the return value (e.g., an array of video objects) since there is no output schema. The agent would be left guessing about how to interpret results and use the parameters effectively, so the description is not sufficient for correct invocation.

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

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

Schema description coverage is 0%, meaning the input schema provides no explanations for query, pageSize, or pageIndex. The description does not compensate by explaining the meaning of these parameters. It only mentions the search query implicitly, but does not define the parameters or their roles (e.g., that pageSize limits results, pageIndex controls pagination). With zero schema coverage, the description fails to provide essential 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 uses a specific verb ('Search'), identifies the external resource ('Pexels'), and narrows the content type ('background videos') with concrete use cases ('welcome/end screens, questions'). This clearly distinguishes it from sibling search tools like search_photos (images) and search_services, so an agent can infer the tool's scope without opening the schema.

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

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

The description implies the tool should be used when a video background is needed, but it does not explicitly state when to use this tool over alternatives or any exclusions. There is no mention of search_photos or search_services, nor conditions like 'use this for videos, search_photos for images.' The usage context is reasonably clear but left to inference rather than 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?

Annotations already indicate the operation is non-read-only, idempotent, and non-destructive. The description adds the ability to clear by passing null and the permission constraint 'Owner/admin only', providing context beyond what annotations convey. This is consistent with the annotations.

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

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

The description is a single sentence with no unnecessary words. It front-loads the core action, mentions the null option, and includes the permission requirement, all in a compact and well-structured format.

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

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

Despite having only two parameters and no output schema, the description is incomplete. It fails to map 'id' to the custom domain, which is essential for correct invocation. Without this, an agent cannot be certain which identifier to pass, making the tool under-documented for its simple complexity.

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

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

With 0% schema description coverage, the description must explain parameters. It clarifies that 'formId' can be null to clear the default, but it does not explain that 'id' refers to the custom domain identifier. The role of 'id' is ambiguous, leaving a critical documentation gap.

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 (pin or clear) and the resource (default form of a custom domain at its root). It is distinct from sibling tools like add_custom_domain and remove_custom_domain, which target domain lifecycle management rather than the default form.

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 only mentions the permission requirement 'Owner/admin only', but does not provide explicit when-to-use guidance or contrast with alternatives. An agent must infer that this tool is for configuring a domain's landing form, which is not obvious without additional 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?

The description's 'AI-generate' indicates a read-only suggestion operation, which aligns with the readOnlyHint=true annotation. The description does not add behavioral context beyond that (e.g., that it returns categories but does not persist them), but annotations already cover the non-mutating nature, so the bar is lower. No contradiction detected.

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, focused sentence with no filler. It states exactly what the tool does without wasted words, making it highly 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?

Given the tool's simplicity (one parameter, no output schema, read-only annotations), the description covers all essential aspects: it generates suggested hot/warm/cold scoring criteria for a form. Nothing critical is missing; a note about the returned format might help but is not strictly required since there is no output schema.

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

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

The schema covers 100% of the parameters (the single 'id' with description 'The form ID'), so the description is not required to add param details. The description does not mention the parameter or any additional semantics, which is acceptable given the 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?

The description specifies a clear action ('AI-generate') and resource ('hot/warm/cold lead-scoring criteria for a form'), which distinguishes it from sibling tools like update_scoring_criteria (which persists criteria) and get_form_scoring_state (which reads current state). It does not fully elaborate on the difference but is specific enough to convey the intent.

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 is given on when to use this tool versus alternatives. It does not mention that it should be used to obtain suggestions before applying them via update_scoring_criteria, nor any preconditions or exclusions. The context is implicit at best.

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 idempotentHint=true, readOnlyHint=false, destructiveHint=false. The description adds valuable context: it verifies membership and persists for the connection, which are behavioral traits not covered by annotations. It does not contradict any annotation.

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