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

With no annotations, the description carries the transparency burden. It adds meaningful behavioral detail: 'Returns compact confirmation by default — set verbose=true for full response.' This clarifies the response format and the effect of the verbose flag, which is not obvious from the schema alone. It does not disclose potential side effects like initial sync or permissions, but provides useful behavior beyond the basic create action.

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

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

The description is two sentences, front-loaded with the primary purpose, and contains no filler. Every sentence contributes: the first states the action, the second provides guidance on discovering config and return behavior.

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

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

Given 7 parameters, a nested config object, and no output schema, the description adequately orients the user by referencing get_connector_metadata for config discovery and explaining the default vs verbose response. It does not detail every parameter, but the schema covers those, and the description supplies the necessary context for successful usage.

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

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

Schema description coverage is 100%, so the baseline is 3. The description adds value by explaining how to approach service-specific config via get_connector_metadata and by clarifying the verbose parameter behavior ('set verbose=true for full response'). This goes beyond the schema's generic parameter 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 action: 'Create a new Fivetran connection (connector)' with a specific verb and resource. It also distinguishes from siblings by pointing to get_connector_metadata for discovery, and the name itself contrasts with update/delete/list 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 guides the user to use get_connector_metadata to discover connector types and required config before creating, providing a clear alternative context. However, it does not explicitly state when not to use this tool (e.g., for updating existing connections), so it lacks full 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?

With no annotations, the description discloses critical behavioral traits: the deletion is permanent ('cannot be undone') and cascades to all synced data configuration. However, it omits other useful context such as required permissions, success/failure response format, or behavior if the connection is currently syncing.

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 clearly convey the action and permanence. No filler or redundant wording.

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

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

The description is adequate for a simple delete operation, but it does not mention what the API returns, whether any prerequisites exist, or error cases. Given the lack of an output schema, a bit more detail on return values would improve completeness.

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

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

The input schema fully documents both parameters (connection_id and verbose) with descriptions, so the description need not add more. The tool description does not expand on parameter semantics beyond the schema.

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

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

The description clearly states the action ('delete'), the resource ('a connection'), and the scope ('all its synced data configuration'), distinguishing it from sibling tools like update_connection or get_connection_details. It is specific and unambiguous.

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

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

No guidance is provided on when to use this tool versus alternatives, when not to use it, or any prerequisites (e.g., pausing the connection first). The description is purely declarative.

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?

No annotations are provided, so the description carries the transparency burden. It discloses that write operations return compact summaries by default and that verbose=true provides full responses. However, it does not mention authentication, rate limits, or error handling, and only indirectly implies destructive capability via the method enum.

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: the first states the purpose, the second gives two actionable guidelines (use search first, and verbose behavior). No wasted words, and the key information is front-loaded.

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

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

For a 5-parameter generic HTTP tool with no output schema, the description covers the main caveat (write operations return compact summaries) and directs users to the search tool for discovery. It doesn't specify GET default responses or pagination behavior, but is sufficient for basic use.

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

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

Schema description coverage is 100%, so the baseline is 3. The description's note about verbose=true duplicates the schema description for the verbose parameter, adding no new parameter semantics. Other parameters (method, path, params, body) are already well-described in the schema.

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

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

The description begins with 'Execute any Fivetran REST API call,' a specific verb and resource that clearly identifies it as a generic raw API executor. This distinguishes it from the many dedicated sibling tools that cover specific endpoints.

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 instructs to 'Use the search tool first to discover available endpoints and their parameters,' providing a clear workflow directive. It implies for general API calls, but does not explicitly contrast with specific sibling tools like 'create_connection' when those are more appropriate.

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

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

With no annotations provided, the description carries the burden of behavioral disclosure. It clearly signals a read-only operation via the verb 'Get' and lists the returned information categories. It does not address error handling or side effects, but for a simple getter this is acceptable.

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, front-loaded with the action and resource, and efficiently lists the key content areas without unnecessary words.

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

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

For a one-parameter getter with no output schema, the description outlines the main information categories, giving sufficient context for an agent to decide to use it. It stops short of describing the exact return format or error behavior, but the tool's simplicity reduces the need for more.

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 provides a complete description for the single parameter, including an example, so baseline is 3. The tool description adds no extra parameter semantics beyond what the schema already offers.

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 'Get' and clearly identifies the resource as 'detailed information for a specific connection.' It enumerates the content categories (config, status, sync state, schedule), which distinguishes it from sibling tools like list_connections, get_connection_schema, and get_sync_status.

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

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

The description clearly implies usage for retrieving details on a single, known connection, contrasting with listing operations. However, it does not explicitly reference alternative tools or state when not to use it, 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?

No annotations are provided, so the description must carry the transparency burden. The verb 'get' implies a read-only operation, but the description does not explicitly state that there are no side effects, nor does it mention any special behaviors like pagination or error conditions. It is adequate but lacks explicit 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, front-loaded sentence that immediately states the action and object, followed by specifics. There is no wasted or redundant wording.

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

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

For a simple get tool with one parameter and no output schema, the description sufficiently explains the return content (schemas, tables, columns, enabled/disabled state). It lacks details on output format or error handling, but for a read-only schema lookup this is acceptable.

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% (connection_id is described as 'The connection ID'), so the baseline is 3. The description adds no additional parameter meaning beyond what the schema already provides; it only contextualizes that the schema is for a connection.

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 gets the schema configuration for a connection, specifying the contents (schemas, tables, columns, enabled/disabled state). This specific verb+resource combination distinguishes it from siblings like get_connection_details (connection metadata) and reload_schema (refetching 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: use this when you need to view a connection's schema configuration. However, it does not explicitly mention alternatives or state when not to use it, such as distinguishing from get_connection_details or update_connection_schema.

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?

No annotations are provided, so the description carries the full burden. It implies a read-only operation through 'Get' and 'discover', but it does not explicitly state that no resources are modified, mention authentication requirements, or describe response structure. The description adds minimal behavioral context beyond what the name and verb already suggest.

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 exactly two sentences, front-loaded with the core action and resource, followed immediately by a practical usage hint. Every sentence earns its place with no filler or redundancy.

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

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

For a simple single-parameter metadata tool, the description provides enough context to invoke correctly: it explains the purpose, how to use it to discover supported connector types, and implicitly the 'service' filter behavior. There is no output schema, but the return type ('configuration schemas') is reasonably implied. It lacks explicit examples or shape details, but those are not essential for this level of 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 coverage is 100%: the single optional 'service' parameter is fully described in the schema. The tool description adds context about 'configuration schemas' and 'what config each requires', aligning with the parameter's purpose, but it does not introduce new syntax or details beyond the schema. This meets the baseline for full schema coverage.

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

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

The description uses a specific verb 'Get' with a clear resource: 'available connector types and their configuration schemas'. It clearly differentiates this metadata-discovery tool from sibling tools like get_connection_details or list_connections, which operate on specific connections rather than catalog-level metadata.

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 second sentence provides explicit usage context: 'Use this to discover what connectors Fivetran supports and what config each requires.' It doesn't state explicit exclusions or name alternatives, but the context is clear enough for an agent to know when to select this tool over connection-specific 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?

With no annotations provided, the description carries the full burden of behavioral disclosure. It only states that it lists connections; it does not mention pagination behavior (despite a cursor parameter), whether it returns all pages, or any other behavioral trait such as read-only semantics or rate limits. This leaves significant room for misinterpretation.

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, front-loaded with the action and scope. Every word earns its place, and there is no extraneous 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?

This is a simple list tool with three parameters, one required, and a complete schema. The description adequately conveys the core purpose, and the schema handles pagination parameters. Since no output schema is present, a bit more detail about the return format could help, but for this level of complexity, the description 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 description coverage is 100%, with each parameter (limit, cursor, group_id) having a description. The tool description adds no additional meaning beyond the schema; it just reaffirms that the group_id is the filter. Per the rubric, baseline 3 is appropriate when schema fully documents parameters.

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

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

The description 'List all connections within a specific group' uses a specific verb (List) and resource (connections) with a clearly scoped target (a specific group). It distinguishes itself from sibling tools like list_connections by implying group-level filtering, 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 for retrieving connections tied to a group, but it does not explicitly state when to use this tool versus alternatives like list_connections. There are no exclusions or alternative recommendations, so it relies on the reader to infer the group-scoped context 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?

With no annotations provided, the description carries the full burden of behavioral disclosure. It states the tool returns connection state including sync history and warnings, but does not disclose potential side effects (though 'Get' implies read-only), error behavior, rate limits, or data format. The description is minimal and does not add meaningful context beyond what the name suggests.

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 the primary action front-loaded: 'Get sync logs for a connection.' The second sentence adds the return content. There is no extraneous information or redundancy, making it appropriately 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?

The tool is simple with one parameter and no output schema or annotations. The description covers the basic purpose and return content, but lacks details on the nature of the logs (e.g., chronological order, pagination, error handling) and any prerequisites. For a tool of this complexity, it is minimally viable but leaves room for additional 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 100% coverage with the parameter description 'The connection ID.' The tool description does not add further meaning beyond referencing 'a connection.' Since the schema already documents the parameter well, the description adds no additional semantic value, matching the baseline for 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 uses a specific verb+resource combination: "Get sync logs for a connection." It clearly identifies what the tool does and what it returns (connection state, sync history, warnings). While it doesn't explicitly distinguish from siblings like get_sync_status, the mention of "sync history and warnings" implies a more detailed output than a basic status tool, giving it reasonable purpose 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 provides no guidance on when to use this tool versus alternatives like get_sync_status. It does not specify scenarios (e.g., troubleshooting sync issues, reviewing past runs) or state when not to use it. The usage context is only implied by the tool name and description, leaving the agent to infer suitability.

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

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

With no annotations, the description carries full behavioral burden. It discloses the return fields (sync state, last sync time, schedule, warnings/failures), which sets expectations, but it does not explicitly state that the operation is read-only, side-effect-free, or mention any permission or error conditions. For a simple get, this is acceptable but not fully transparent.

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 directly states the resource and the specific data fields returned. It is front-loaded, contains no redundant words, and every part adds value.

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

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

For a simple read-only status tool with one parameter and no output schema, the description adequately explains what it does and what information it provides. It could be more explicit about behavioral aspects (e.g., read-only confirmation), but it does not leave the agent wondering about the tool's core purpose or return content.

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

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

The input schema describes the only parameter (connection_id) as 'The connection ID', providing 100% coverage. The description adds no extra meaning or usage details about this parameter beyond the schema, so the baseline score 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's function: 'Get the current sync status for a connection' and enumerates the included data ('sync state, last sync time, schedule, and any warnings or failures'). This specific verb+resource+scope distinguishes it from siblings like get_connection_details or get_sync_logs.

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

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

The description implies the tool is to be used when checking current sync status, but it does not explicitly state when to use it over alternatives such as get_connection_details or get_sync_logs. No exclusions or alternative tool names are provided, so guidance is only implied.

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?

No annotations are provided, so the description carries the full burden. The 'Get' verb implies a read-only operation, and the description lists the returned fields (enabled state, sync mode, metadata). However, it does not disclose any behavioral traits such as whether the operation fails for invalid connection_ids, whether it triggers any side effects, or how the response is structured. For a simple read tool, 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, front-loaded sentence that presents the main action and the key output components without superfluous words. Every phrase adds value, and the structure is clear and 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 tool with one parameter and no output schema, the description gives a high-level summary of the response content (enabled state, sync mode, metadata). It could be more precise about the response format or fields included under 'metadata', but it covers the core information an agent needs to decide whether this tool fits the request. The presence of sibling tools like get_sync_status and get_sync_logs creates a need for more explicit distinction, which is partially met.

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, connection_id, is documented in the schema with 'The connection ID'. The description adds no additional semantic detail beyond placing it in the context of per-table sync status. Since schema coverage is 100%, the baseline is 3, and the description does not elevate beyond that.

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 identifies the resource 'per-table sync status for a connection', then lists the specific content: 'enabled state, sync mode, and metadata'. This clearly distinguishes it from sibling tools like get_sync_status (overall sync status) and get_sync_logs (logs).

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 the use case: querying per-table sync status for a connection. It does not explicitly exclude alternatives, but the contrast with sibling tool get_sync_status is apparent from the wording and name. It provides enough context for an agent to select this tool over others, though it stops short of naming alternatives explicitly.

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

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

With no annotations, the description carries the burden of behavioral disclosure. It does mention the default compact confirmation and the verbose option for full response, which is useful. However, it does not disclose side effects (e.g., email sending), required permissions, or behavior if the role is omitted, leaving some behavioral gaps.

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. It states the core purpose first, then uses a dash to add the key behavioral detail about response format. Every word contributes value, with no redundancy.

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

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

Given the tool's low complexity (simple parameters, no output schema), the description adequately covers the return behavior (compact vs full). It does not address edge cases like duplicate invites or role defaults, but the schema handles parameter details. Overall, sufficiently complete for a straightforward invite tool.

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

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

Schema coverage is 100%, so all parameters are already described in the schema. The description does not add meaning beyond the schema, referencing 'specified role' and 'verbose=true' but without additional detail. This matches the baseline of 3 for full schema coverage.

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

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

The description clearly states a specific action ('Invite a new user') on a specific resource ('the Fivetran account'), with an additional qualifier ('with a specified role'). The verb 'invite' is distinct from all sibling tools, eliminating ambiguity about which tool to select.

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

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

The description implies the tool is used for inviting users but provides no explicit guidance on when to use it versus alternatives (there are none for inviting) or any prerequisites/exclusions. The context is clear from the name and action, but the description does not elaborate on scenarios or conditions.

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

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

With no annotations provided, the description carries the burden of behavioral disclosure. It says 'List all' but doesn't disclose that pagination via limit and cursor may be required to retrieve truly all connections. It also doesn't explicitly state that the operation is read-only, though that is implied. The phrase 'with their sync status' gives some return context but lacks details about pagination behavior.

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

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

The description is two sentences, front-loaded with the core purpose, and contains no wasted words. It efficiently communicates the main function and optional filtering.

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

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

Without an output schema, the description should clarify return values. It mentions 'sync status' but does not explain pagination details, default limits, or how to handle cursors. Given the pagination parameters, the description is somewhat incomplete for a list operation that may not return all results in a single response.

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

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

Schema coverage is 100% for all three parameters, so the baseline is 3. The description only repeats the group filter concept ('Optionally filter by group') and adds no additional meaning 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 ('List') and the resource ('Fivetran connections (connectors)') and distinguishes itself from siblings like get_connection_details (singular) and get_sync_status (specific status) by indicating it returns connections with sync status. The optional group filter aligns with the group_id parameter.

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 the tool (when you need a list of connections) and mentions an optional filter. However, it does not explicitly state when to use alternatives, such as get_connection_details for a single connection or get_sync_status for a specific sync status, which is a missing exclusion.

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

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

With no annotations, the description carries the full burden for behavioral disclosure. It states the tool lists destinations and returns configuration/status, but it does not disclose that 'all' may be subject to pagination via the limit parameter, potentially misleading the agent. It also does not explicitly confirm read-only behavior, though 'list' implies it. The description adds minimal context beyond what the schema already provides.

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

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

The description is a single, well-structured sentence that immediately conveys the action, resource, and return content. There is no redundant or filler wording; every word contributes, making it concise and effectively front-loaded.

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

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

Given the tool's simplicity (two optional parameters, no output schema, no annotations), the description is minimally viable. It provides the essential purpose and return scope ('configuration and status'), but lacks explicit notes on pagination behavior, response format, or safety profile. Since the schema covers pagination parameters, the missing details are not critical, but the overall completeness is adequate rather than rich.

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

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

The input schema has 100% coverage for both parameters (limit and cursor) with descriptions, so the baseline is 3. The description does not add any additional meaning about parameter usage, defaults, or how they affect the result, but given the schema already covers these, no further description is necessary to reach the 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 clearly states the action ('List all destinations'), the resource type ('destinations'), and the scope ('in the account'). It also specifies what information is returned ('configuration and status'), which differentiates it from sibling tools like list_connections by focusing on the destinations 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 gives no guidance on when to use this tool instead of alternatives such as list_connections, get_connection_details, or get_connector_metadata. There are no exclusions, prerequisites, or contextual hints about the relationship between destinations and connections. No usage context beyond the basic listing action is 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?

No annotations are provided, so the description must carry the full burden of behavioral disclosure. While 'List all groups' clearly indicates a read-only operation, it does not explain pagination behavior (e.g., cursor usage) or what the response structure looks like, which are relevant given the absence of an output 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 a single, front-loaded sentence with zero wasted words. It conveys the essential purpose and scope 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?

The tool is simple (2 optional params, no output schema, no annotations). The description, combined with the schema, gives a reasonably complete picture for a list operation. However, the lack of output schema and explicit pagination details leaves minor gaps in what the agent can expect as a return value.

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

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

The input schema covers 100% of the parameters (limit and cursor) with clear descriptions. The tool description adds no additional parameter semantics beyond the schema, 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 uses a specific verb ('List') and resource ('groups (workspaces)') with clear scope ('all groups in the Fivetran account'). This distinguishes it from sibling tools that target connections, destinations, users, and other resource types.

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 enumerate groups, but it does not explicitly state when to use this tool versus alternatives, nor does it mention any exclusions or prerequisites. The guidance is limited to the stated purpose itself.

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?

No annotations are provided, so the description bears full responsibility for behavioral disclosure. The phrase 'List all teams' suggests a single, complete listing, but the schema includes limit and cursor parameters indicating pagination. The description does not clarify that 'all' may require multiple calls or explain the pagination behavior, which is a meaningful gap.

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, complete sentence that is perfectly front-loaded. It conveys the essential action and scope without any redundant or verbose language, 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?

Given the low complexity and complete parameter documentation, the description is adequate but not fully complete. There is no output schema, and the description does not mention the return format (e.g., array of team objects) nor clarify how pagination interacts with the 'all teams' claim. These gaps prevent a higher score.

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% with clear descriptions for both 'limit' and 'cursor'. The tool description adds no extra meaning beyond this, so the baseline score of 3 is appropriate; the schema already communicates the parameter semantics adequately.

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 ('teams') with explicit scope ('in the Fivetran account'), clearly distinguishing this from sibling list tools such as list_groups, list_users, and list_connections. It is immediately obvious what action is performed and on what entity.

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

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

The description does not provide any guidance on when to use this tool versus the many sibling list tools. While the name implies listing teams, there is no mention of prerequisites, exclusions, or alternatives. This leaves the agent to infer usage from the resource 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?

With no annotations provided, the description carries the full burden of behavioral disclosure. It simply states that it lists all users, but does not mention pagination, the effect of the limit parameter, or any authorization requirements. The implied read-only behavior is not explicitly confirmed, and important operational details are absent.

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

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

The description is a single, clear sentence with no filler or redundant wording. It is front-loaded with the action and resource, earning high marks for conciseness, even though it sacrifices 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?

Given the tool's pagination parameters and lack of output schema or annotations, the description is too minimal. It does not mention that results are paginated, the response format, or any behavioral caveats, leaving the agent without a complete understanding of how to fully utilize the tool.

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

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

The input schema fully describes both parameters (limit and cursor) with descriptions and constraints, providing 100% schema coverage. The description adds no extra semantics beyond what the schema already specifies, 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 uses the specific verb 'List' with the resource 'users' and scope 'in the Fivetran account'. It clearly distinguishes from sibling tools like list_connections or invite_user, 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?

No guidance is provided on when to use this tool versus alternatives such as list_teams or search. The description does not mention any prerequisites, exclusions, or comparison to other tools, leaving the agent without explicit selection criteria.

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

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

With no annotations provided, the description carries the full burden. It discloses key behavioral outcomes: the connection will not sync until resumed and the default response is a compact confirmation. It stops short of detailing side effects on in-flight syncs or required permissions, but covers the essential behavior for a simple state-changing 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 precise sentences with no filler. The first sentence states the intended action, the second explains the consequence and response behavior. 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 two-parameter tool with no output schema, the description fully covers what the tool does, its effect, and how to get more detail. It is complete and appropriate for the tool's complexity, especially among sibling tools with obvious opposites.

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

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

Schema description coverage is 100%, so the baseline is 3. The description's note about compact confirmation and verbose=true essentially repeats the schema's verbose description, adding no new parameter-level meaning 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 uses a specific verb ('Pause') and identifies the exact resource ('a connection's sync schedule'), making the tool's purpose unmistakable. It also distinguishes itself from sibling tools like resume_connection and trigger_sync by stating the effect of the pause.

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: to pause a connection's sync schedule. It also hints at the opposite operation ('until resumed') but doesn't explicitly name resume_connection as the alternative. The verbose flag instruction adds usage context but no formal exclusions 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?

No annotations exist, so the description must carry the burden. It discloses the return behavior (compact confirmation, verbose option for full response) and the core action of detecting changes, but does not specify whether the operation is idempotent, what side effects occur on existing schema, or any authorization/rate-limit concerns.

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 action, followed by the detection behavior and return format. It contains no filler and is appropriately sized for the tool's simplicity.

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

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

For a simple two-parameter tool with no output schema, the description covers the purpose, behavior, and return options. However, without annotations, it lacks explicit guidance on when to use this versus the schema-related sibling tools and does not disclose side effects or error conditions, leaving moderate gaps.

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

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

The input schema already describes both parameters (verbose and connection_id) with 100% coverage. The description adds only a redundant hint about setting verbose=true, providing no additional semantic value beyond the schema.

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

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

The description clearly states the verb 'Reload', the resource 'schema configuration', and the source. It also specifies what it detects (new tables, columns, schema changes), which distinguishes it from read-only schema retrieval tools like get_connection_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 you want to refresh the schema from the source after changes, but it does not explicitly state when to use it over sibling tools like get_connection_schema or update_connection_schema, nor does it provide 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?

With no annotations, the description carries the full burden. It discloses the core action, the deferred sync behavior, and the response format (compact by default, verbose with flag). This is solid, though it doesn't address edge cases like already-active connections or error conditions.

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

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

Two concise sentences that front-load the primary action, then provide the most relevant behavioral detail (scheduled sync and response format). No waste.

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

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

For a simple two-parameter tool with no output schema, the description covers the purpose, the key timing behavior, and response verbosity. It is sufficient for a competent agent to select and invoke correctly.

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

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

Schema description coverage is 100%, so both parameters are already documented. The description reinforces that verbose=true returns full response, but adds no additional meaning beyond the schema.

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

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

The description starts with a clear verb+resource construction: 'Resume a paused connection.' This directly states what the tool does and distinguishes it from siblings like pause_connection and trigger_sync.

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 clearly explains when to use the tool (when a connection is paused) and gives a key condition: it will sync on the next scheduled interval, not immediately. This implicitly contrasts with trigger_sync, though it doesn't name alternatives explicitly.

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

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

With no annotations, the description carries the full transparency burden. It does disclose return behavior (compact confirmation by default, verbose option) and scope limitation, but lacks details on potential side effects, permissions required, or whether this is a long-running operation. This is adequate but not comprehensive.

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

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

Two sentences, front-loaded with the verb and resource. Every sentence earns its place with no filler or redundancy.

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

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

For a 3-parameter tool with full schema coverage, the description clearly explains the operation's scope and return behavior. It lacks some context on execution time, error scenarios, or data impact, but remains sufficiently complete for an agent to use 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?

Schema description coverage is 100%, so parameters are already well-documented. The description adds slight reinforcement by mentioning 'verbose=true for full response' and referencing 'tables', but does not introduce significant new meaning beyond the schema.

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

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

Description clearly states the action ('Force a historical resync') and the resource ('specific tables within a connection'). It also distinguishes from siblings by explicitly noting that only the specified tables are re-synced, not the entire connection, which differentiates it from tools like trigger_sync.

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 on scope ('Only re-syncs the specified tables, not the entire connection') and implies when to choose this tool over a full-sync alternative. It does not explicitly name the alternative but offers de facto guidance on 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?

With no annotations, the description carries the burden of disclosure. It explains return contents and the no-argument behavior, which is useful. However, it does not explicitly state whether the operation is read-only or mention rate limits or authentication, though the search nature makes these less critical. The disclosure is adequate without being exhaustive.

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 each sentence earns its place. The second sentence adds a valuable usage tip without 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 search tool with no output schema, the description adequately explains the return values and provides a key usage example. It could mention pagination or result ordering, but the schema's limit parameter covers pagination implicitly. Overall, it is sufficiently complete for an agent to select and invoke the tool.

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

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

The input schema has 100% coverage of parameter descriptions, so the baseline is 3. The description adds no additional parameter semantics beyond what the schema already provides, such as examples or parameter relationships. It does not compensate beyond the schema's 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 the Fivetran REST API catalog to discover endpoints. It specifies the resource (API catalog), the verb (search), and the output (method, path, summary, parameter details), distinguishing it from sibling tools that perform specific 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 provides clear context for use (discovering endpoints) and a specific usage tip (call with no arguments to see categories), but it does not explicitly state when to use this tool over alternatives or provide exclusions. This is close to a 4 but lacks explicit sibling differentiation.

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

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

With no annotations provided, the description carries the full burden of behavioral disclosure. It does disclose output behavior ('Returns compact confirmation by default — set verbose=true for full response'), which is useful. However, it does not explicitly state whether the tool is read-only or if running tests has any side effects, and it does not describe what the tests actually do beyond 'verify connectivity and configuration.' This partial transparency meets the minimum but leaves gaps.

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

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

The description is two concise sentences, front-loaded with the primary purpose, and then provides the key behavioral detail about output verbosity. Every word earns its place, with no fluff or repetition.

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

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

For a tool with only two parameters and simple semantics, the description provides adequate context: what it does, the default output behavior, and how to change it. It does not have an output schema, so the description of 'compact confirmation' vs 'full response' partially compensates. However, it could be more complete by hinting at what the confirmation includes or indicating that the tool is safe to run (read-only). Still, the core information needed to invoke and interpret is present.

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 includes descriptions for both parameters ('destination_id' and 'verbose') with 100% coverage. The description adds no new meaning; the mention of 'verbose=true' simply restates the schema's parameter description. Since schema coverage is high, 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 function: 'Run setup tests for a destination to verify connectivity and configuration.' This is a specific verb ('run setup tests') with a resource ('destination') and a clear goal. It also distinguishes from siblings by focusing on testing/verification, which none of the other connection-related tools explicitly do.

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—during destination setup to verify connectivity—but does not explicitly state when to use this over alternatives or provide any exclusions. It lacks guidance such as 'use after creating or updating a destination' or 'use instead of get_connection_details for verification purposes.' The context is clear but not explicit enough to warrant a higher score.

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

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

Discloses the default response behavior (compact confirmation) and how to get the full response via `verbose`. With no annotations, the description carries the burden; however, it does not mention side effects, whether the sync is asynchronous, or behavior when a sync is already running beyond the `force` parameter.

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

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

Two sentences, no wasted words. Front-loads the core action, then adds response behavior. Perfectly sized for the information provided.

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 trigger tool, the description covers the key purpose and response format. It lacks details on auth requirements or error conditions, but the schema fills in parameter meanings and the tool is not complex enough to demand more.

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

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

Schema coverage is 100%, so the baseline is 3. The description adds value by explaining the default response and how `verbose` alters it, but does not go beyond schema for `force` or `connection_id`.

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

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

Clearly states the action ('Trigger an immediate sync') and the resource ('for a connection'). Distinguishes from scheduled syncs and sibling tools like `get_sync_status` or `resync_tables` by emphasizing immediate execution.

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

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

Provides clear context: use when you want a sync now rather than waiting for the next scheduled interval. Does not explicitly name alternatives or state when not to use, so just short of a 5.

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

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

No annotations are provided, so the description carries the burden of behavioral disclosure. It discloses the default compact confirmation and the verbose option, which is useful. However, it doesn't describe mutability semantics, permissions, or error behavior, leaving gaps for a write operation.

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

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

The description is two sentences, front-loaded with the primary purpose and adding a single key behavioral note. Every word earns its place, and it is exceptionally concise.

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

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

The description covers the main action and one behavioral trait (verbose output). With six parameters, a nested config object, and no output schema, more detail about return values or update semantics would help, but it's adequate for basic use.

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 descriptions cover 100% of parameters, so the description doesn't need to add much. It does mention the verbose parameter behavior implicitly, but the description adds no extra meaning beyond the schema. 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 updates a connection's configuration, schedule, or settings, which is a specific verb+resource action. It distinguishes from sibling tools like pause_connection, trigger_sync, or update_connection_schema by covering the general update scope.

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

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

The intended use is implied by the name and description, but there's no explicit guidance on when to prefer this over alternatives. It doesn't mention that update_connection_schema is for schema changes, which could create ambiguity. No exclusion or alternative guidance is 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?

No annotations are provided, so the description carries the full burden of behavioral disclosure. It does mention the default compact confirmation and the verbose flag for a full schema response, adding some transparency. However, it omits details on permissions, reversibility, or whether the update is partial or full replacement, which would be valuable for a mutation tool.

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

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

The description is two concise sentences: the first states the action and scope, the second explains the response behavior. No fluff or redundancy, making it 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 3-parameter tool with a nested object and no output schema, the description is adequate but not rich. It covers the core purpose and response behavior, but does not explain the structure of the schemas object or potential edge cases. The schema partially compensates, but the description could be more complete for a mutation tool.

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

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

The schema covers all parameters (100% coverage), so the baseline is 3. The description adds slight clarification about the enable/disable semantics of the 'schemas' parameter and the effect of 'verbose', providing marginal value beyond the schema descriptions themselves.

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 ('Update schema config') and its scope ('enable/disable schemas, tables, or columns for a connection'). This distinguishes it from sibling tools like get_connection_schema (reading) and reload_schema (refreshing), 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?

Usage is implied: this tool is for modifying schema configuration. However, it does not explicitly mention alternatives or when not to use it, such as using get_connection_schema for reading or reload_schema for refreshing. The guidance is adequate 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.