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

Annotations cover key behavioral traits (read-only, non-destructive, idempotent, closed-world), but the description adds value by specifying 'authenticated' session, implying it requires prior authentication. This context isn't in the annotations, enhancing transparency without contradiction.

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

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

The description is a single, clear sentence that front-loads the essential information ('Show the current authenticated TunnelHub session') with zero wasted words. It's appropriately sized for a simple, parameterless 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?

Given the tool's simplicity (0 parameters, no output schema) and rich annotations, the description is adequate but minimal. It lacks details on output format or error cases, which could be helpful for the agent, though annotations mitigate some gaps.

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

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

With 0 parameters and 100% schema coverage, the baseline is 4 as there are no parameters to document. The description doesn't need to compensate for any gaps, so it meets expectations without adding unnecessary 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 clearly states the action ('Show') and resource ('current authenticated TunnelHub session'), making the purpose evident. However, it doesn't explicitly differentiate from sibling tools like 'list_sessions_tunnelhub' or 'get_tenant_tunnelhub', which might also relate to session or authentication data, so it falls short of a perfect score.

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 doesn't mention prerequisites (e.g., being logged in), exclusions, or compare to siblings like 'list_sessions_tunnelhub' or 'login_tunnelhub', leaving the agent to infer usage context.

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

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

Annotations cover key traits (non-readOnly, openWorld, non-idempotent, non-destructive), so the bar is lower. The description adds some context by noting it's 'manually' dispatched and follows the UI flow, hinting at user-initiated execution. However, it doesn't disclose additional behavioral aspects like rate limits, authentication needs, or side effects 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, efficient sentence with zero waste—it directly states the action and context. It's appropriately sized and front-loaded, making it easy to parse without 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?

Given the tool's complexity (executing automations with a payload), lack of output schema, and 0% schema coverage, the description is inadequate. It doesn't explain what the tool returns, how errors are handled, or prerequisites (e.g., needing a valid automationId). With annotations providing some safety context but no output details, it leaves significant gaps 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 description coverage is 0%, so the description must compensate but fails to do so. It mentions no parameters, leaving 'automationId' and 'payload' entirely undocumented. While 'automationId' is self-explanatory, 'payload' could vary widely (string/object), and the description provides no insight into its purpose or format.

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 ('dispatch') and resource ('TunnelHub automation'), specifying it's done manually and follows the UI flow. It distinguishes from siblings like 'list_automations_tunnelhub' or 'get_automation_tunnelhub' by focusing on execution rather than retrieval, though it doesn't explicitly contrast with execution-related tools like 'find_execution_tunnelhub'.

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 minimal guidance, mentioning it's 'same flow used by the UI' which implies a manual trigger context, but offers no explicit when-to-use rules, alternatives (e.g., vs. automated triggers), or exclusions. Given multiple sibling tools for executions and automations, this lack of differentiation is a significant gap.

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 key behavioral hints: readOnlyHint=true, destructiveHint=false, idempotentHint=true, and openWorldHint=false. The description adds some context by mentioning 'resolve its execution period,' which suggests additional processing beyond simple retrieval. However, it doesn't disclose important details like pagination behavior (implied by 'current' and 'pageSize' parameters), rate limits, authentication needs, or what 'resolve' entails operationally.

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 efficiently states the core purpose. It's front-loaded with the main action. However, it could be slightly more structured by explicitly separating the finding and resolving aspects, but this is minor.

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

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

Given the tool's complexity (8 parameters, 2 required, low schema coverage) and lack of output schema, the description is insufficient. It doesn't explain the return values, pagination, filtering logic (e.g., how parameters interact), or what 'resolve its execution period' means in practice. With annotations covering safety but not operational behavior, more detail is needed for effective 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 low at 25%, with only 'startDate' and 'endDate' having descriptions. The description mentions 'required date range,' which aligns with these two required parameters but doesn't add meaning beyond what the schema provides. It doesn't explain the purpose of other parameters like 'automationId,' 'status,' 'hideEmptySuccess,' or 'executionId,' leaving significant gaps in parameter understanding.

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

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

The description clearly states the tool's purpose: 'Find an execution within a required date range and resolve its execution period.' It specifies the verb 'find' and resource 'execution' with scope 'within a required date range.' However, it doesn't explicitly distinguish this tool from sibling tools like 'list_automation_executions_tunnelhub' or 'get_execution_tunnelhub,' which appear to have overlapping functionality.

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 minimal guidance, stating only that it finds executions 'within a required date range.' It doesn't explain when to use this tool versus alternatives like 'list_automation_executions_tunnelhub' (which might list executions without date constraints) or 'get_execution_tunnelhub' (which might retrieve a single execution by ID). No explicit when-not-to-use or prerequisite information is included.

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 cover key traits (read-only, non-destructive, idempotent, closed-world), so the bar is lower. The description adds minimal context by specifying 'action logs' as the resource, but doesn't disclose behavioral details like rate limits, auth needs, or pagination behavior (implied by 'current' and 'pageSize' parameters). It doesn't contradict annotations, so no penalty.

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 with zero waste, front-loaded with the core purpose. It's appropriately sized for a simple tool, making it easy to parse quickly.

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

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

Given the tool's complexity (3 parameters, no output schema) and rich annotations, the description is incomplete. It lacks parameter semantics, usage guidelines, and details on return values or behavior beyond annotations. For a tool with pagination parameters and no output schema, more context is needed to be fully helpful.

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, but it adds no parameter information. It doesn't explain what 'automationId', 'current', or 'pageSize' mean or how they affect the output (e.g., pagination). With 3 parameters and no schema descriptions, this is a 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 clearly states the verb ('Read') and resource ('action logs for a TunnelHub automation'), making the purpose specific and understandable. However, it doesn't explicitly differentiate from sibling tools like 'get_execution_logs_tunnelhub' or 'get_execution_traces_tunnelhub', which may also involve logs, so it doesn't fully distinguish from alternatives.

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

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

The description provides no guidance on when to use this tool versus alternatives, such as 'get_execution_logs_tunnelhub' or 'list_automation_executions_tunnelhub'. It lacks context on prerequisites (e.g., needing an automation ID) or exclusions, leaving the agent with minimal usage direction.

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

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

Annotations cover key behavioral traits (read-only, non-destructive, idempotent, closed-world), so the bar is lower. The description adds value by specifying it retrieves 'details' by ID, which implies it returns comprehensive information about a single automation, but doesn't elaborate on format or limitations. 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 extremely concise at 5 words, front-loaded with the core action, and has zero wasted words. It efficiently conveys the essential purpose without 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?

Given the tool's low complexity (1 parameter, no output schema) and rich annotations, the description is minimally adequate. However, it lacks details on what 'details' include, potential errors, or how it differs from siblings, making it incomplete for optimal agent use despite annotations covering safety aspects.

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 1 parameter with 0% description coverage, but the description adds minimal semantics by indicating 'automationId' is used to get details. However, it doesn't explain what an automationId is, its format, or where to find it, leaving gaps. Baseline is 3 since the schema lacks descriptions, but the description 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 automation details by id' clearly states the verb ('Get') and resource ('automation details'), making the purpose understandable. However, it doesn't differentiate from sibling tools like 'get_execution_tunnelhub' or 'list_automations_tunnelhub', which would require specifying it retrieves a single automation by ID rather than listing multiple or getting execution 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 provides no guidance on when to use this tool versus alternatives. For example, it doesn't mention that this is for retrieving a specific automation by ID, as opposed to 'list_automations_tunnelhub' for multiple automations or 'get_execution_tunnelhub' for execution details. There's no context on prerequisites or exclusions.

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

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

Annotations already indicate read-only, non-destructive, and idempotent behavior, so the description doesn't need to repeat these. It adds minimal context by specifying 'for one automation execution', but doesn't disclose other traits like rate limits, authentication needs, or what 'logs' entail (e.g., format, size). 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, efficient sentence that directly states the purpose without unnecessary words. It's front-loaded and appropriately sized, 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?

Given the tool's complexity (7 parameters, 3 required) and lack of output schema, the description is minimal. Annotations cover safety aspects, but the description doesn't address return values, pagination hints (implied by parameters like 'pageSize'), or error conditions. It's adequate as a basic read operation but leaves gaps for effective 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 low at 14%, with only 'executionPeriod' having a description. The tool description doesn't explain any parameters, leaving most (like 'current', 'pageSize', 'totalPreCalculated', 'lastEvaluatedKey') undocumented. This fails to compensate for the schema's gaps, adding no 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 'Get' and resource 'execution logs for one automation execution', making the purpose evident. However, it doesn't differentiate from sibling tools like 'get_execution_traces_tunnelhub' or 'get_automation_action_logs_tunnelhub', which likely retrieve related but different data, so it's not fully specific.

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

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

The description provides no guidance on when to use this tool versus alternatives such as 'get_execution_traces_tunnelhub' or 'list_automation_executions_tunnelhub'. It lacks context about prerequisites, exclusions, or typical scenarios, leaving the agent to infer usage 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?

Annotations already provide clear hints: readOnlyHint=true, destructiveHint=false, idempotentHint=true, and openWorldHint=false. The description doesn't contradict these but adds minimal behavioral context beyond them—it specifies 'for one automation execution,' which implies a scope limitation. However, it lacks details on rate limits, authentication needs, or what 'traces' entail (e.g., format, depth).

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 that states the tool's purpose without unnecessary words. It's appropriately sized and front-loaded, making it easy to understand at a glance. Every word earns its place, with no redundancy or fluff.

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

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

Given the tool's complexity (11 parameters, 3 required) and low schema coverage (9%), the description is insufficient. It lacks output schema, so it should explain return values or behavior, but it doesn't. With annotations covering safety, more context is needed on what 'traces' include, pagination (implied by 'nextToken' and 'cursor'), or filtering (via parameters like 'level' and 'status').

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 very low at 9%, with only one parameter ('executionPeriod') having a description. The tool description adds no information about parameters, failing to compensate for the poor schema coverage. With 11 parameters (3 required), the description should clarify meanings, usage, or relationships (e.g., how 'executionId', 'automationId', and 'executionPeriod' interact), but it doesn't address any of them.

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 as 'Get execution traces for one automation execution,' which is a specific verb+resource combination. However, it doesn't distinguish this tool from sibling tools like 'get_execution_logs_tunnelhub' or 'get_execution_tunnelhub,' leaving some ambiguity about what makes 'traces' different from 'logs' or general execution 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 provides no guidance on when to use this tool versus alternatives. With siblings like 'get_execution_logs_tunnelhub' and 'get_execution_tunnelhub,' it's unclear what specific scenarios or data needs warrant using this tool for 'traces' over others. No explicit when/when-not instructions or alternative tool references are included.

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 cover key behavioral traits (read-only, non-destructive, idempotent, closed-world), so the bar is lower. The description adds minimal context by listing required parameters, but doesn't disclose additional behaviors like rate limits, authentication needs, or what 'summary details' entail. It doesn't contradict annotations, so it's adequate given the annotation coverage.

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

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

The description is a single, efficient sentence that front-loads the purpose and lists parameters. There's no wasted text, but it could be slightly more structured (e.g., separating purpose from requirements) for optimal clarity.

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

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

Given the tool's moderate complexity (3 required parameters) and rich annotations, the description is minimally complete. However, with no output schema and low parameter coverage, it lacks details on return values and parameter semantics, leaving gaps that could hinder effective use by 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 description coverage is low at 33%, with only 'executionPeriod' having a description. The description lists the three required parameters but doesn't add meaning beyond their names (e.g., what 'automationId' represents or how 'executionId' is formatted). Since it doesn't compensate for the low coverage, it meets the baseline for minimal value.

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

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

The description clearly states the verb ('Get') and resource ('execution summary details for one automation execution'), making the purpose specific and understandable. However, it doesn't explicitly differentiate from sibling tools like 'find_execution_tunnelhub' or 'summarize_execution_tunnelhub', which prevents a perfect score.

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

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

The description mentions required parameters but provides no guidance on when to use this tool versus alternatives like 'find_execution_tunnelhub' or 'summarize_execution_tunnelhub'. There's no context about use cases, prerequisites, or exclusions, leaving the agent with minimal usage direction.

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

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

The description adds 'read-only details' which aligns with the annotations (readOnlyHint: true, destructiveHint: false), but doesn't provide additional behavioral context beyond what annotations already cover. Annotations clearly indicate it's safe and idempotent, so the description's value is minimal but not contradictory.

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 key information ('Get read-only details for a tenant by id'). There is no wasted verbiage, making it highly concise and well-structured for quick comprehension.

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

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

Given the simple input schema (one parameter) and rich annotations, the description is adequate but minimal. It lacks output details (no output schema) and doesn't explain usage context relative to siblings, leaving gaps in completeness for effective tool 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?

With 0% schema description coverage and only one parameter, the description compensates by specifying that it retrieves details 'by id', which clarifies the purpose of the 'tenantId' parameter. This adds meaningful context beyond the bare schema, though it could be more detailed.

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 ('read-only details for a tenant by id'), making the purpose understandable. However, it doesn't differentiate from sibling tools like 'list_tenants_tunnelhub' or 'get_execution_tunnelhub', which might cause confusion about when to use this specific retrieval tool versus others.

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 doesn't mention sibling tools like 'list_tenants_tunnelhub' for listing tenants or 'get_execution_tunnelhub' for other get operations, leaving the agent without context for tool selection.

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 cover key behavioral traits (read-only, non-destructive, idempotent, closed-world), so the description's burden is lower. It adds context by specifying 'deploy history', which implies a historical log, but does not disclose additional details like pagination, sorting, or rate limits. No contradiction with annotations exists.

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 that directly states the tool's function without unnecessary words. It is front-loaded and efficiently conveys the core purpose, 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?

Given the tool's low complexity (1 parameter, no output schema) and rich annotations, the description is minimally adequate. It covers the basic purpose but lacks details on output format, error handling, or integration with sibling tools, leaving gaps for a complete understanding in 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?

With 0% schema description coverage, the description does not add any parameter details beyond the schema, which only defines 'automationId' as a required string. The description mentions 'for a TunnelHub automation', hinting at the parameter's purpose, but this is minimal and does not fully compensate for the lack of 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 verb 'List' and the resource 'deploy history for a TunnelHub automation', making the purpose specific and understandable. However, it does not explicitly differentiate from sibling tools like 'list_automation_executions_tunnelhub', which might list executions rather than deploys, leaving some ambiguity in sibling distinction.

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

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

The description provides no guidance on when to use this tool versus alternatives, such as 'list_automation_executions_tunnelhub' or 'get_automation_tunnelhub'. It lacks context on prerequisites, exclusions, or specific scenarios for deployment history, offering minimal usage direction.

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

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

Annotations already declare readOnlyHint=true, destructiveHint=false, idempotentHint=true, and openWorldHint=false, covering safety and idempotency. The description adds value by emphasizing the mandatory date range constraint ('required date range'), which isn't covered by annotations. It doesn't contradict annotations, but also doesn't provide additional behavioral details like pagination or rate limits.

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

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

The description is extremely concise with two sentences that are front-loaded and waste no words. Every sentence directly contributes to understanding the tool's purpose and key constraints, making it efficient and well-structured.

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

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

Given the tool's complexity (7 parameters, no output schema), the description is minimal but adequate with annotations covering safety. It clarifies the mandatory date range, which is critical, but lacks details on parameter usage, return format, or pagination. This makes it a baseline viable description but with clear gaps for a listing 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 low at 29%, with only 'startDate' and 'endDate' having descriptions. The description mentions 'startDate and endDate are mandatory,' which adds semantics for these two parameters but doesn't cover the other five parameters (current, pageSize, automationId, status, hideEmptySuccess). This partial compensation is insufficient given the low coverage.

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

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

The description clearly states the tool's purpose as 'List automation executions for a required date range,' which includes a specific verb ('List') and resource ('automation executions'). It distinguishes from siblings like 'find_execution_tunnelhub' (likely for single executions) and 'get_execution_tunnelhub' (likely for details), but doesn't explicitly differentiate them.

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

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

The description implies usage by specifying that 'startDate and endDate are mandatory,' which provides context for when to use this tool (i.e., when you have a date range). However, it doesn't explicitly state when to use alternatives like 'find_execution_tunnelhub' or 'get_execution_tunnelhub,' nor does it mention exclusions or prerequisites.

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

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

Annotations cover read-only, non-destructive, idempotent, and closed-world behavior, so the description adds value by specifying the source ('integrations-service') and environment constraint ('current environment'). It doesn't contradict annotations and provides useful operational context, though it lacks details like rate limits or 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 a single, efficient sentence with no wasted words. It front-loads the core purpose and includes essential context without redundancy, 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?

Given annotations cover safety and idempotency, and there's no output schema, the description is minimally adequate but incomplete. It lacks parameter explanations, usage guidance, and details on return values or pagination, leaving gaps for a list operation with filtering parameters.

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

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

Schema description coverage is 0%, so the description must compensate but provides no parameter information. It doesn't explain what 'current', 'pageSize', 'name', or 'status' mean or how they affect the listing. This leaves all 4 parameters undocumented beyond the schema, failing to add semantic value.

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

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

The description clearly states the action ('List automations') and resource ('from integrations-service'), with specific context ('using the current environment'). It distinguishes from siblings like 'get_automation_tunnelhub' (single automation) and 'list_automation_executions_tunnelhub' (different resource), though not explicitly. However, it lacks explicit sibling differentiation, preventing a perfect score.

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 mentions 'using the current environment' but doesn't clarify prerequisites like needing authentication or compare with siblings such as 'list_automation_deploys_tunnelhub' for different data. This leaves the agent without usage context.

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

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

Annotations already indicate read-only, non-destructive, and idempotent behavior, so the description adds minimal value by specifying 'available to the current authenticated user', which implies authentication context. However, it does not disclose additional traits like rate limits, pagination, or response format, keeping it basic.

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 that efficiently conveys the core purpose without any wasted words. It is front-loaded and appropriately sized for a simple listing 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?

Given the tool's simplicity (0 parameters, no output schema) and rich annotations, the description is adequate but minimal. It covers the basic action and authentication scope but lacks details on output structure or behavioral nuances, making it just sufficient for a read-only list 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?

With 0 parameters and 100% schema description coverage, the schema fully documents the input (none). The description adds no parameter details, which is acceptable here as there are no parameters to explain, so it meets the baseline for this scenario.

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 resource ('environments available to the current authenticated user'), making the purpose unambiguous. However, it does not explicitly differentiate from sibling tools like 'list_tenants_tunnelhub' or 'list_sessions_tunnelhub', which also list resources, so it misses full sibling distinction.

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

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

The description provides no guidance on when to use this tool versus alternatives. It lacks any mention of context, prerequisites, or exclusions, such as how it relates to tools like 'switch_environment_tunnelhub' or 'get_tenant_tunnelhub', leaving usage unclear.

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

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

Annotations cover key behavioral traits (read-only, non-destructive, idempotent, closed-world), but the description adds valuable context by specifying that it lists 'saved' sessions and that they are stored 'in local MCP storage', which clarifies the data source and persistence aspect. This goes beyond annotations without contradicting them, enhancing the agent's understanding of the tool's 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 a single, efficient sentence that front-loads the core purpose without any wasted words. It directly addresses what the tool does, making it easy for an agent to parse and understand quickly, 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?

Given the tool's low complexity (0 parameters, no output schema) and rich annotations, the description is adequate but minimal. It covers the basic purpose and data source, but lacks details on output format, pagination, or error handling, which could be helpful despite the annotations. It meets minimum viability but has clear gaps in 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?

With 0 parameters and 100% schema description coverage, the baseline is high. The description implicitly confirms there are no required inputs by not mentioning any, which aligns with the schema. It adds no extra parameter details, but given the absence of parameters, this is sufficient for clarity, earning a score above 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 specific action ('List'), resource ('saved TunnelHub sessions'), and scope ('in local MCP storage'), which distinguishes it from siblings like list_automations_tunnelhub or list_environments_tunnelhub that list different resources. It precisely communicates what the tool does without 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 provides no guidance on when to use this tool versus alternatives, such as how it differs from other list_* tools in the sibling set or when to prefer it over other session-related tools like current_session_tunnelhub. It lacks explicit context, prerequisites, or exclusions, offering only a basic statement of function.

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

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

Annotations already indicate read-only, non-destructive, and idempotent behavior, which the description reinforces with 'read-only lookup.' The description adds value by specifying that tenants are 'visible to the authenticated user,' providing context beyond annotations. No contradiction with annotations is present.

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

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

The description is two sentences, front-loaded with the core action, and every word earns its place. It efficiently conveys purpose and intent without unnecessary elaboration, 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?

Given the tool's simplicity (0 parameters, no output schema) and rich annotations, the description is complete enough for a list operation. It covers the scope and intent, though it could benefit from mentioning output format or pagination to enhance completeness 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?

With 0 parameters and 100% schema description coverage, the baseline is high. The description does not need to explain parameters, and it appropriately focuses on the tool's purpose without redundant parameter details, adding semantic clarity about the scope of listing.

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 resource ('tenants visible to the authenticated user'), making the purpose specific and understandable. However, it does not explicitly differentiate from sibling tools like 'get_tenant_tunnelhub' (which likely retrieves a single tenant), leaving room for improvement in sibling distinction.

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

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

The description implies usage for read-only lookup, but does not provide explicit guidance on when to use this tool versus alternatives such as 'get_tenant_tunnelhub' or other list tools. It offers some context ('visible to the authenticated user') but lacks clear when-to-use or when-not-to-use statements.

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 cover key traits (non-readOnly, openWorld, non-idempotent, non-destructive), so the bar is lower. The description adds context about the 'browser-based frontend auth flow', hinting at interactive behavior, but doesn't detail side effects (e.g., session creation), rate limits, or auth requirements. 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?

Single sentence, front-loaded with the core purpose, no redundant words. Efficiently conveys the essential action and method without fluff, making it 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 no output schema and annotations covering basic traits, the description is minimally adequate. It lacks details on return values, error handling, or session implications post-login, leaving gaps for an authentication tool with potential side effects.

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

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

Schema description coverage is 100%, providing full parameter documentation. The description adds no parameter-specific information beyond implying authentication context. Baseline 3 is appropriate as the schema carries the burden, but no extra value is added.

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 ('Authenticate') and target ('TunnelHub'), specifying the method ('browser-based frontend auth flow'). It distinguishes from siblings like 'logout_tunnelhub' by focusing on login, but doesn't explicitly differentiate from other auth-related tools (none present).

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 is provided. It doesn't mention prerequisites (e.g., needing credentials), when authentication is required, or relate to siblings like 'current_session_tunnelhub' for session checks. Usage is implied but not articulated.

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

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

Annotations indicate destructiveHint=true and idempotentHint=true, which the description aligns with by implying session removal. The description adds value by specifying it can target 'current or a specific saved' session, clarifying scope beyond what annotations provide. However, it doesn't detail effects like authentication loss or rate limits, leaving some behavioral aspects uncovered.

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 that efficiently conveys the core action without unnecessary words. It's front-loaded with the main purpose, making it easy for an agent to parse quickly. Every part of the sentence earns its place by specifying 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?

Given the tool's complexity (destructive session management), annotations cover safety (destructive, idempotent) but lack output schema. The description adds basic scope but misses details like return values, error conditions, or dependencies on other tools. It's minimally adequate but has clear gaps for a mutation tool with 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 input schema has 1 parameter with 0% description coverage, and the description doesn't explain the 'sessionId' parameter's meaning or usage. Since schema coverage is low, the description should compensate but fails to do so, offering no param details. The baseline is 3 because the description doesn't contradict the schema but adds no semantic value.

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

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

The description clearly states the action ('Remove') and resource ('current or a specific saved TunnelHub session'), making the purpose evident. However, it doesn't explicitly differentiate from sibling tools like 'list_sessions_tunnelhub' or 'switch_environment_tunnelhub', which also involve session management, so it doesn't fully distinguish itself from alternatives.

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 doesn't mention prerequisites (e.g., needing an active session from 'login_tunnelhub'), exclusions, or compare it to siblings like 'switch_environment_tunnelhub' for session changes. This leaves the agent without context for tool selection.

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

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

Annotations provide readOnlyHint=true, destructiveHint=false, idempotentHint=true, and openWorldHint=false, covering safety and idempotency. The description adds value by specifying the scope of the summary ('details, logs, and traces'), which isn't in the annotations. However, it lacks behavioral details like rate limits, authentication needs, or output format (no output schema exists). With annotations covering core traits, a 3 is appropriate for adding some 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, efficient sentence: 'Summarize one execution with details, logs, and traces.' It's front-loaded with the core action and includes all necessary elements without waste. 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?

Given the tool's complexity (summarizing execution data), annotations cover safety and idempotency, but there's no output schema. The description specifies the scope ('details, logs, and traces'), which helps, but it lacks details on output format, error conditions, or prerequisites. For a tool with three required parameters and no output schema, this is minimally adequate but leaves gaps for the agent to infer.

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 33% (only 'executionPeriod' has a description). The description doesn't mention any parameters, leaving 'executionId' and 'automationId' undocumented in both schema and description. It fails to compensate for the low coverage, as it provides no parameter semantics beyond what's implied by the tool name (e.g., that 'executionId' identifies the execution to summarize).

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: 'Summarize one execution with details, logs, and traces.' This specifies the verb ('summarize'), resource ('execution'), and scope ('details, logs, and traces'). It distinguishes from siblings like 'get_execution_tunnelhub' (likely just basic info) or 'get_execution_logs_tunnelhub' (just logs). However, it doesn't explicitly contrast with these siblings in the description text itself.

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 doesn't mention prerequisites (e.g., needing an execution ID), compare to siblings like 'get_execution_tunnelhub' (basic info) or 'get_execution_logs_tunnelhub' (logs only), or specify use cases (e.g., for debugging or reporting). The agent must infer usage from the name and context 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?

Annotations provide key behavioral hints (non-readOnly, openWorld, idempotent, non-destructive), so the description's burden is lower. It adds context about affecting the 'current session,' which isn't covered by annotations, but doesn't elaborate on session-specific impacts, error conditions, or confirmation of success. No contradiction with annotations exists.

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 action ('Switch the active TunnelHub environment') without unnecessary words. Every part of the sentence contributes directly to understanding the tool's 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 tool's moderate complexity (session state change), annotations cover safety and idempotency well, but there's no output schema. The description lacks details on what happens after switching (e.g., confirmation message, error handling, or session persistence), leaving gaps in understanding the full behavior despite good annotations.

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

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

Schema description coverage is 100%, with the single parameter 'environmentId' well-documented as a 'Target environment UUID.' The description adds no additional parameter semantics beyond implying the environmentId is used for switching, which aligns with the schema. Baseline 3 is appropriate given high schema coverage.

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

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

The description clearly states the action ('switch') and target resource ('active TunnelHub environment for the current session'), making the purpose unambiguous. However, it doesn't explicitly differentiate from sibling tools like 'list_environments_tunnelhub' or 'current_session_tunnelhub', which would require mentioning this tool changes the active environment rather than just retrieving information.

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 doesn't mention prerequisites (e.g., needing to list environments first), exclusions, or relationships to sibling tools like 'list_environments_tunnelhub' (which might be needed to obtain environment IDs) or 'current_session_tunnelhub' (which might show the current environment).

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