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 only states 'Creates a new calendar event' without disclosing side effects, permission requirements, or whether the event is persistent. For a mutation tool, this lacks sufficient behavioral context.

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

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

The description is concise and well-structured with a lead sentence and bullet points for key parameters. It is front-loaded and every sentence earns its place, though the content is very short. It could be considered under-specified, so not a 5.

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

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

With 6 parameters, no annotations, and a mutation operation, the description is incomplete. It does not explain return values (though output schema exists), prerequisites, or side effects. It covers only basic creation and two parameter hints. Insufficient for an intelligent agent to invoke safely and correctly.

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

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

Schema coverage is 0%, so the description must compensate. It does add useful info by specifying calendar_name examples and ISO-8601 format for timestamps, which are critical. However, it omits the semantics of summary, start_iso, end_iso (beyond format), location, and description, leaving gaps for 6 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 explicitly states 'Creates a new calendar event' using a clear verb (Creates) and resource (calendar event). This distinguishes it from sibling tools like get_upcoming_calendar_events and delete_calendar_event. However, it could better specify the event's scope or requirements, so it does not earn a 5.

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

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

The description implies it is used to create a calendar event, and sibling tools clearly cover retrieval and deletion. However, it provides no explicit guidance on when to choose this tool over alternatives (e.g., when to use add_google_task or create_github_issue). Usage is implied, not stated.

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

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

No annotations are provided, so the description must disclose behavioral traits. It only includes the due_iso format, omitting auth requirements, side effects, error conditions, or what happens on success/failure. The mutation is implicit but not detailed, leaving the agent without critical behavioral context.

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

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

The description is concise and front-loaded: the first sentence states the core action, and the second adds essential format detail. No wasted words, and the structure makes the tool's purpose immediately obvious.

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 presence of an output schema reduces the need to explain return values, but the description still lacks usage guidance and parameter context. Given the simplicity of a create operation, it's minimally viable, but an agent would benefit from more context about task creation, such as handling of notes defaults or potential conflicts.

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

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

The schema has 0% description coverage, so the description must compensate. It explains only due_iso format, leaving the required 'title' and optional 'notes' semantically underdefined. The agent cannot infer the expected content or constraints of the primary required parameter from the description.

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

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

The description clearly states the tool's function: 'Creates a new Google Task.' The verb 'creates' plus the resource 'Google Task' specifically distinguishes it from sibling task tools like list_google_tasks, complete_google_task, and delete_google_task. Mentioning due_iso format adds practical detail 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?

Usage is implied—use when you need to create a Google Task—but the description does not explicitly contrast with add_calendar_event or other 'add' tools, nor does it provide when-not-to-use guidance or mention alternatives. It lacks explicit context about which scenarios favor this tool.

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

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

No annotations are provided, so the description carries the burden of disclosing behavior. It accurately indicates a mutating action ('Adds'), but it does not explain potential side effects, authorization requirements, or that issue_number can accept pull request IDs—though this last nuance is partially covered by the phrase 'issue or pull request'.

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

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

A single, clear sentence conveys the essential action and target without any fluff. Every word contributes to understanding, and the description is front-loaded with the primary verb.

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

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

Despite the lack of parameter details, the tool is simple and an output schema exists, so return values need no explanation. The description fully captures the core functionality. The only omission is usage context, but that is covered separately and the tool's simplicity makes the description adequate.

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

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

Schema description coverage is 0%, so the description must add meaning. It clarifies that issue_number can refer to either an issue or a pull request, which is non-obvious from the bare schema. However, repo_name and comment_body are left entirely to their names, with no format or constraints explained.

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 ('Adds a comment') and clearly identifies the resource ('existing issue or pull request'). It distinguishes itself from sibling tools like create_github_issue and list_github_issues by focusing on the commenting action for both issues and PRs.

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 explicit guidance on when to use this tool versus alternatives. While no sibling tool directly comments, the description does not mention prerequisites, scenarios, or exclusions, leaving usage largely 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?

With no annotations, the description must disclose behavioral traits. It states 'creates or updates,' which implies mutation, but it fails to mention that it commits and pushes, how it handles existing files, branch behavior, authentication requirements, or failure modes. The name hints at commit/push, but the description itself lacks these critical details.

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

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

The description is a single sentence with no superfluous words, which is concise. However, it is under-specified for a tool with five parameters and a mutation operation. It is too brief to be considered 'appropriately sized' for the tool's complexity, though not as egregious as a tautology.

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

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

The tool has an output schema, but the description does not mention result formats or side effects. Given that this is a write operation on a GitHub repository with no annotations and zero parameter documentation, the description is incomplete. It leaves out key context like branch defaults, overwriting behavior, commit semantics, and potential errors.

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

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

Schema description coverage is 0%, and the description does not compensate. It does not explain the meaning or usage of any of the five parameters (repo_name, file_path, content, commit_message, branch). While parameter names are self-explanatory to some extent, the description adds zero 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 tool's function: 'Creates or updates a file directly in a GitHub repository.' This uses a specific verb (creates/updates) and a distinct resource (file in a GitHub repository), which distinguishes it from sibling tools that handle calendar events, tasks, issues, and PRs. No ambiguity about what the tool does.

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

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

The description provides no guidance on when to use this tool versus alternatives, nor does it mention any prerequisites or exclusions. While sibling tools exist for GitHub issues and PRs, the description does not contrast file operations with those, so usage context is entirely absent.

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

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

No annotations are provided, so the description carries full responsibility for behavioral disclosure. It implies a mutation (status change) but does not mention idempotency, error behavior, auth requirements, or what happens if the task is already completed. The output schema is present but not described, so the agent lacks context on return values.

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 directly states the tool's purpose. Every word earns its place, with no fluff or repetition. It is appropriately concise for a simple operation.

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

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

Given the tool's low complexity (one parameter) and the presence of an output schema (which can convey return structure), the description is reasonably complete. It covers what the tool does and how to invoke it. The main gaps are behavioral nuances (e.g., failure cases) but these are less critical for a straightforward completion action.

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's parameter is a bare string 'task_id' with no description. The description clarifies that this is the ID of the Google Task being completed, which adds meaning. However, it does not provide format, source, or validation details, and there is only one parameter, so the added value is modest.

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 ('Marks a Google Task as completed') and the resource/method ('using its Task ID'). It distinguishes from sibling tools like add_google_task or delete_google_task because it specifically addresses completing an existing task.

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

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

The description gives no guidance on when to use this tool versus alternatives, nor any prerequisites or exclusions. It simply states the action, leaving the agent to infer when completion is appropriate. No mention of when not to use it or related tools like list_google_tasks.

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 must disclose behavioral traits, but it only says 'creates a new issue'. It does not mention side effects, authorization requirements, rate limits, or the immediate persistence of the issue. This is a gap similar to the 'update_drive' example.

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

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

The description is a single concise sentence that front-loads the primary action and resource. It is appropriately brief for a simple create operation, though it sacrifices necessary detail for brevity.

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

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

The tool has 4 parameters and no annotations, and the description offers no parameter semantics or usage guidance. While an output schema exists, it does not cover invocation details. The agent is left uncertain about the expected format of repo_name and optionality of labels, making the description insufficient for correct 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 description provides zero parameter information, and schema coverage is 0%. Parameter names like repo_name, title, body, and labels are not explained. For instance, repo_name likely expects 'owner/repo' format, but this is not stated. The description does not compensate for the schema's lack of 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 ('Creates a new issue') and the target resource ('GitHub repository'), which is specific and distinct from sibling tools like comment_github_issue (comment vs create) and create_github_pull_request (issue vs PR).

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 create_github_pull_request or comment_github_issue. There is no mention of 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?

With no annotations provided, the description must carry the full burden of behavioral disclosure. It only states that it creates a pull request, which signals a mutation, but it does not disclose potential side effects (e.g., whether it updates branches, requires authentication, or can fail due to merge conflicts), nor does it mention the return value or error 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 exactly one short sentence, conveying the core purpose with no wasted words. It is perfectly concise and front-loaded.

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

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

The tool has 5 parameters, 4 required, and no annotations or parameter descriptions. Although an output schema is said to exist, the description does not explain which branches are needed, what the default base_branch is, or what happens after creation. The minimal text is not sufficient to fully guide an agent through correct invocation, especially given the 0% schema coverage.

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

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

Schema description coverage is 0%, so the description must compensate for the lack of parameter documentation. It does not mention any parameter, and the schema property names alone (repo_name, title, body, head_branch, base_branch) are only marginally self-explanatory. The description provides no added meaning or guidance on parameter values, formats, or relationships.

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 is a clear, specific verb+resource statement: 'Creates a new pull request.' It unambiguously identifies the action and subject, and the name itself distinguishes it from sibling tools like create_github_issue or list_github_pull_requests.

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 usage is implicitly clear from the name and description: use this when you need to create a pull request. However, there is no explicit guidance about when to prefer this over alternatives (e.g., creating an issue, committing and pushing a file), nor any prerequisites or preconditions mentioned.

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

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

With no annotations provided, the description carries full responsibility for behavioral disclosure. It only mentions 'automatic scan fallback', which is vague and unexplained. It does not state whether deletion is permanent, requires specific permissions, or has side effects like cascading deletions, which is critical for a destructive 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 a single sentence, front-loaded with the action and resource. It is concise and avoids redundancy. However, the phrase 'with automatic scan fallback' is vague and could be clearer or omitted, slightly diminishing the efficiency of the text.

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

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

For a destructive operation with 2 parameters and an output schema, the description is under-specified. It omits essential context such as the meaning and implications of the automatic fallback, any return value expectations, and whether confirmation or permissions are required. The description does not fully equip an agent to handle edge cases.

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

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

Schema description coverage is 0%, so the description must compensate. It mentions 'event_id' but does not clarify the role of 'calendar_name' (optional, default 'primary') or what 'automatic scan fallback' means for parameter usage. The description adds minimal meaning beyond the schema itself.

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 ('Deletes') and the resource ('calendar event'), with the method 'by its ID'. It distinctly separates this tool from siblings like get_upcoming_calendar_events and add_calendar_event. The phrase 'automatic scan fallback' is odd but does not obscure the core purpose.

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

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

The description implies usage when deletion is needed, but provides no explicit guidance on when to use this instead of alternatives, nor does it mention prerequisites such as first fetching events to obtain an ID. There is no exclusions or comparison to sibling tools, leaving the agent to infer 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?

No annotations are provided, so the description must disclose behavioral traits. It states 'Deletes' but does not indicate whether the deletion is permanent, irreversible, or what happens to subtasks or non-existent tasks. For a destructive mutation tool, this is minimal disclosure and leaves important behavioral unknowns.

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

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

The description is a single, front-loaded sentence with no filler or redundant information. Every word contributes to communicating the core action and required input.

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

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

The tool is simple (one parameter) and an output schema exists, so return-value details are covered elsewhere. However, the lack of annotations and missing behavioral context such as permanence or error behavior leaves the description only minimally complete for a destructive operation. It is adequate but has clear 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 has one parameter (task_id) with no description, so the phrase 'by its Task ID' adds semantic value by connecting the parameter to the Google Task being deleted. However, it does not explain the ID format or how to obtain it, and the meaning is largely inferable from the parameter name.

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 ('Deletes') and clearly identifies the resource ('Google Task') with scope ('by its Task ID'). This distinguishes it from sibling tools like list_google_tasks, add_google_task, and complete_google_task, which perform different actions on the same 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?

No usage context is provided. The description does not mention when to delete a task versus completing it (complete_google_task), nor any prerequisites like obtaining the Task ID from list_google_tasks. There is no guidance on alternatives 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?

No annotations exist, so the description must disclose behavioral traits. It only states what is returned, without revealing side effects, read-only nature, latency, or auth requirements. 'Returns' implies a read, but not explicitly safe.

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

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

The description is a single, front-loaded sentence with no filler. It 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?

With an output schema present and no parameters, the description adequately covers the tool's purpose. No missing information for a simple status endpoint.

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?

Zero parameters are present in the schema, so the description need not explain parameter details. Baseline 4 is appropriate for a no-parameter tool.

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

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

The description uses a specific verb 'Returns' and identifies the resource 'gateway' with scope 'runtime diagnostics and status metadata'. It clearly distinguishes from sibling calendar/task/github 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?

No explicit when-to-use or alternative guidance is provided. However, the tool's unique purpose among unrelated siblings implies usage for gateway health checks, but the description does not state when to prefer it.

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

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

With no annotations provided, the description carries the full burden. It conveys read-only behavior ('Retrieves') and a key behavioral trait (aggregating across all active Google Calendars) and time scoping ('within next X days'). However, it does not clarify edge cases like event filtering or the meaning of 'active', leaving some ambiguity.

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 communicates the core purpose. No filler or redundant wording, and it front-loads the key verb and resource.

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

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

The tool is a simple read operation with only two optional parameters and an output schema. The description covers the primary behavior (retrieving events) and scope (all active calendars, time range). Minor gaps remain around parameter usage and 'active' semantics, but overall it is adequate given the tool's simplicity and presence of an 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?

Schema description coverage is 0%, so the description must explain parameters. It indirectly references days_ahead via 'next X days' but does not mention max_results or defaults, nor how these parameters control output. The agent must infer from parameter names alone, which is insufficient.

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

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

The description clearly states the tool retrieves upcoming events across all active Google Calendars within a specified time frame. It uses a specific verb ('Retrieves') and resource ('upcoming events across all active Google Calendars'), distinguishing it from calendar mutation tools like add_calendar_event and delete_calendar_event.

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 reading upcoming events but offers no explicit when-to-use/when-not-to-use guidance or mentions of alternative tools. It does provide context that it aggregates across all active calendars, but lacks direct exclusions or comparisons to siblings.

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

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

No annotations are provided, so the description carries the full burden of disclosing behavioral traits. It does not mention pagination, rate limits, authentication requirements, or explicitly confirm it is a read-only operation. It only lists state options, which is more parameter semantics than behavioral transparency.

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

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

Two concise sentences with no filler. The description front-loads the core purpose and immediately follows with necessary parameter details, making it easy to parse and high in information density.

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

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

For a simple list tool with an output schema, the description covers the core purpose and key parameters sufficiently. However, the lack of usage guidelines and behavioral disclaimers (e.g., pagination, read-only confirmation) slightly reduces completeness, though the output schema fills in return-value details.

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 compensates by explaining the repo_name format ('owner/repo') and the valid state values ('open', 'closed', 'all'). This adds meaningful context beyond the raw schema, although it does not note the default state (open) which is available in the schema.

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

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

The description clearly states the tool lists issues for a given repository, using a specific verb and resource. It provides the repo format and accepted state values, distinguishing it from the sibling list_github_pull_requests which handles pull requests.

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 list issues for a specific repository, but it does not explicitly state when to use it versus alternatives or provide any exclusion criteria. The example format and state options give context, but no direct comparison to sibling tools is made.

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 merely says 'lists' without mentioning default state filtering, pagination, or authorization requirements. The state parameter with default 'open' is not disclosed, leaving important behavioral traits undocumented.

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

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

The description is a single concise sentence with no wasted words. It is appropriately front-loaded with the core action and resource.

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

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

The tool has two parameters and an output schema, but the description is extremely sparse. It lacks essential context such as how to specify the repository (full name vs. URL), the effect of the state parameter, and any pagination or sorting details. The description is not sufficient for an agent to invoke the tool correctly in varied situations.

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 should explain parameters. It only hints at repo_name through 'given repository' but entirely ignores the state parameter, its possible values, and its default. This provides minimal value beyond the bare parameter names.

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

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

The description clearly states the action (lists), the resource (pull requests), and the scope (for a given repository). It distinguishes itself from sibling tools like list_github_issues by specifically mentioning pull requests.

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

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

There is no guidance on when to use this tool versus alternatives such as list_github_issues or create_github_pull_request. The usage context is only implied by the verb 'lists' and the resource, with no explicit 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?

With no annotations, the description carries the full burden of behavioral disclosure. It mentions that status and ID are included, but omits key behavioral details such as the default filtering (show_completed defaults to false, meaning completed tasks are excluded by default) and any other behavior like ordering or pagination. This is a significant gap for an unannotated read tool.

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

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

The description is a single concise sentence that front-loads the action and resource. Every word earns its place, and there is no wasted content. It is appropriately sized for a simple tool with one optional parameter.

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

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

Despite being a simple tool, the description is incomplete because it does not explain the default behavior of show_completed, which is central to what tasks are returned. While an output schema exists, it does not cover the filtering semantics. The description should at least mention that only incomplete tasks are listed unless show_completed is enabled.

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% since the description does not mention show_completed. The description adds no meaning beyond the input schema, and with low coverage, the description is expected to compensate. It fails to do so, leaving the parameter's effect on behavior undocumented in the narrative.

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 ('Lists') and resource ('tasks from the primary task list'), and distinguishes this tool from sibling mutating tools like add_google_task, complete_google_task, and delete_google_task. It also hints at output fields (status and ID), 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 read-only usage by saying 'Lists', but it does not explicitly state when to use this tool versus alternatives or mention any exclusions (e.g., tasks from other lists). No guidance is given about the show_completed parameter. The intended use case is implied, not explicitly stated.

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