mcp-gateway

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

No annotations are provided, so the description must carry the full transparency burden. It mentions 'validate and call' but does not disclose potential side effects (e.g., whether the target tool may modify data), error handling, or any validation failure behavior. This leaves significant behavioral 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, focused sentence with no redundant information. It is compact and easy to parse, effectively covering the core functionality without unnecessary verbosity.

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 appears to be a generic caller for other services, but the description does not explain what output it returns, how 'mode' affects execution, or how it relates to the sibling tools beyond 'calling' them. Given the complexity of a meta-tool, this description is too sparse for an agent to fully understand its role.

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 zero schema coverage, the parameter names (mode, tool, service, arguments) are the only hints. The description provides no additional explanation of their meaning, expected values, or relationships. For a meta-tool, this is critically insufficient for correct parameter selection.

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: to validate and call an enabled curated tool. This distinguishes it from the sibling tools, which are specific domain-specific actions (e.g., searching laws, fetching weather alerts).

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 as a general dispatcher for other tools, but it does not explicitly state when to prefer this tool over calling a specific tool directly or mention alternatives. The phrase 'enabled curated tool' hints at a selection mechanism but lacks explicit guidance.

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

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

Beyond the readOnlyHint annotation, the description reveals nothing about the tool's behavior. It does not state what the output looks like, whether it searches a catalog, returns a list of tool names, or provides any details about the execution or side effects. The description adds no transparency beyond the annotation.

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

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

The description is extremely concise, consisting of a single sentence with no unnecessary words. The structure is clear and direct, making it easy to read. However, the brevity sacrifices essential detail, so it is not a perfect score.

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

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

Given the tool's simple interface (one string parameter), the description provides a minimal level of context. However, it fails to explain what 'enabled service tools' are, how they relate to the 'question,' or what the expected output is. This leaves significant gaps for an agent trying to decide whether to use this tool.

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

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

The only parameter, 'question', is not described in the schema, and the description only vaguely hints that it should be a 'plain-language question.' There is no elaboration on the expected format, length, or scope of the question, so the parameter's meaning remains under-specified.

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

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

The description states a clear action ('Find') and a resource ('enabled service tools') with an input ('plain-language question'), which distinguishes it from sibling search tools. However, the term 'capability' is ambiguous and the description does not specify what kind of tools are returned or how they relate to the question, leaving some purpose unclear.

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 instead of the many sibling search tools. It merely says 'for a plain-language question,' which is not a clear condition or scenario. There is no mention of when this tool is the preferred choice or what alternatives exist.

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

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

The readOnlyHint annotation already indicates the tool has no side effects, and the description does not contradict this. However, the description adds no additional behavioral details beyond the annotation, such as edge cases (e.g., start > end) or error conditions. It satisfies the baseline for non-contradiction but does not enrich transparency.

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

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

The description is a single, clear sentence that efficiently conveys the tool's core functionality without unnecessary words or complexity. It is well-structured and immediately understandable.

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

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

The description captures the essential operation of counting inclusive business days in a calendar. It omits details about output format (e.g., whether it returns a number or object) and edge cases, but for a straightforward counting operation, the core context is sufficient. The low parameter coverage is the main gap, but the description's simplicity mitigates this.

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

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

Schema description coverage is only 20% (only 'calendar' has a description), and the tool description does not compensate by explaining 'start' or 'end' beyond implying they are dates. Parameters like 'as_of' and 'snapshot_id' remain entirely unexplained. The description fails to add meaningful parameter context to the sparse 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 counts weekdays between start and end dates that are not holidays, which is a specific and unambiguous purpose. It distinguishes itself from sibling tools like holidays_get_holidays by focusing on the count of business days rather than listing holidays.

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 explicit guidance on when to use this tool over alternatives. It does not mention scenarios where this tool is appropriate or reference sibling tools such as holidays_get_holidays. The purpose implies usage for counting business days, but lacks direct usage instructions.

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 readOnlyHint annotation covers safety, and the description adds behavior beyond that: it returns observed dates and returns no holidays rather than guessing for unsupported years. It does not mention rate limits or side effects, but the read-only annotation sufficiently covers the main concern.

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 compact sentences with the main concept first and the important edge-case note second. No filler or redundant wording.

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

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

With no output schema, the agent relies on the description to understand what will be returned; it states holidays with observed dates but omits the output shape and the role of time-travel/pagination parameters. Adequate for basic selection, but not fully complete for confident invocation.

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

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

Schema description coverage is only 17%—only calendar has a description. The description clarifies calendar/year conceptually, but leaves required year and optional as_of, snapshot_id, limit, and fields without meaningful semantic explanation. With such low schema coverage, the description needed to compensate more.

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 identifies the resource: public holidays for one calendar in one year, with observed dates. It is distinguishable from the sibling count/list tools by its 'get holidays' semantics, though it does not explicitly name those 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?

It gives clear selection context—one calendar, one year—and a useful edge-case behavior (unsupported years return no holidays). However, it does not explicitly say when to prefer this tool over holidays_count_business_days or holidays_list_calendars.

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 readOnlyHint annotation already signals that this is a safe read operation, and the description adds that it returns calendar identifiers and availability metadata. No side effects are implied, and no additional behavioral warnings are needed.

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 brief, focused, and front-loads the core purpose before giving the downstream usage hint. Every sentence contributes useful information.

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

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

For a simple listing tool with no output schema, the description gives enough context about the returned entity and how it feeds into sibling tools. It could mention output fields more fully, but the schema's field enum fills most of that gap.

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

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

The description provides no explanation of the limit or fields parameters, and the schema itself only gives type/enum constraints. Although the field enum names are mostly self-explanatory, the lack of any narrative guidance on filtering or pagination leaves parameter semantics under-specified.

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

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

Description clearly identifies the tool's purpose as listing all calendars exposed by the service, including authority and availability metadata. It stops short of using an explicit verb like 'list', but the meaning is unambiguous.

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

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

Description explicitly tells the agent to use the returned calendar_id as the calendar parameter in holidays_get_holidays and holidays_count_business_days, making the intended workflow clear. It does not explicitly name alternatives or say when not to use this tool, but the guidance is sufficient for typical use.

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

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

The readOnlyHint annotation already indicates safe, non-mutating behavior. The description adds minimal behavioral context (only that it inspects an enabled curated tool), but doesn't clarify potential edge cases like whether mode affects output size or whether it can fail for disabled tools. This is adequate but not enriching.

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

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

The description is one succinct sentence with no fluff or redundancy. It is well-structured and immediately conveys the core purpose without unnecessary detail.

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

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

The tool lacks an output schema, and the description does not mention return values, error behavior, or examples. Given the ambiguity around parameters and the absence of a defined output, the description is not complete enough for an agent to confidently invoke the tool without additional context.

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

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

The schema provides types, required fields, an enum for mode, and a default, but the description offers no explanation of what 'service', 'tool', or 'mode' actually mean semantically. Since schema description coverage is 0%, the description fails to compensate, leaving parameter meaning ambiguous.

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 ('Inspect') and the object ('one enabled curated tool'), making the primary purpose understandable. However, it doesn't elaborate on what 'inspect' entails (e.g., viewing schema, metadata) or differentiate it from sibling tools like find_capability or search_services, so it falls short of 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?

There is no guidance on when to use this tool versus alternatives. The description doesn't mention scenarios, prerequisites, or how it contrasts with search/find tools, leaving the agent to infer appropriate 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?

The readOnlyHint annotation already signals a safe read operation, and the description adds that the law is null when absent. However, it does not explain behavior for as_of or snapshot_id, or any potential error conditions.

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

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

The description is a single concise sentence, though the phrasing is slightly grammatically awkward. It is appropriately short and does not waste words.

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

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

Without an output schema, the description should clarify the return shape more thoroughly. It mentions null when absent but omits details about the law object's fields, as_of/snapshot semantics, and possible errors, leaving some gaps for a complete 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?

Only law_id is referenced in the description ('by the id'), leaving as_of and snapshot_id unexplained. Since the schema provides no descriptions, these parameters remain ambiguous beyond their 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 indicates the tool returns a single law by its ID and mentions null when absent, which distinguishes it from search_laws. However, the phrase 'search_laws returned' is awkward and could confuse the tool's exact role.

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

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

No explicit guidance is provided on when to use this tool versus alternatives like laws_search_laws or laws_list_law_types. The distinction is only implicit in the 'by id' wording.

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

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

The description does not mention side effects, but the readOnlyHint annotation already covers read-only behavior. However, the description adds no further behavioral transparency (e.g., whether it returns a list, pagination, or ordering).

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

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

The description is very concise (one line) and avoids verbosity, but it is too terse to be informative. It does not follow a clear structure (e.g., verb + object) and reads more like a fragment.

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

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

The description is insufficient for an agent to understand the tool's role within the laws domain. It does not explain what a 'law type' is, how it relates to snapshots, or why search_laws would need it, leaving the purpose incomplete.

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?

None of the three parameters (as_of, limit, snapshot_id) are described. The schema allows nulls and constraints on limit, but the description offers no explanation of their purpose or expected values.

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 'The law types in the snapshot, as search_laws expects them in type' is vague and does not clearly state the tool's function. It hints at listing law types but fails to specify the action (e.g., 'List all law types') and the relationship to search_laws is unclear.

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 laws_search_laws or laws_get_law. There is no mention of prerequisites, use cases, or conditions that would help an agent select 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?

The readOnlyHint annotation already signals no side effects, and the description does not contradict it. The description adds that each hit links to official XML, but it does not elaborate on pagination or cursor behavior.

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

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

The description is two sentences, directly front-loads the core purpose, and contains no redundant or misleading content.

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

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

There is no output schema, and the description only partially covers the request semantics. It omits guidance on pagination, field selection, snapshot usage, and response shape, so an agent may not know how to fully utilize the tool.

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

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

The description explains query, type, and since, but the schema has zero parameter descriptions and the other five parameters (as_of, limit, cursor, fields, snapshot_id) are not explained. This leaves significant ambiguity for an agent trying to construct a correct request.

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 returns Federal Acts and regulations matching a title query, and the tool name reinforces the search intent. It is distinguishable from related law tools like laws_get_law and laws_list_law_types.

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

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

The description explains the query, type, and date-filtering semantics, and points to laws_list_law_types for valid type values. It does not explicitly state when to prefer this tool over laws_get_law or other law-related searches, though the sibling names imply the distinction.

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

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

The description discloses the key behavior of returning null when the dataset is absent, which goes beyond the readOnlyHint annotation. It does not mention rate limits or auth, but the read-only nature is covered by annotation.

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

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

The description is a single, concise sentence that packs essential information without superfluous details. It is well-structured and easy to parse.

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

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

The description provides the core purpose and null behavior, but lacks details on optional parameters and the shape of 'full metadata'. Since there is no output schema, more context on the return type would be 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?

Only dataset_id is hinted at in the description ('the id search_datasets returned'). The optional parameters as_of and snapshot_id are completely unexplained, and the description does not compensate for the 0% 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 tool retrieves full metadata for a single dataset by ID, and explicitly notes the null return when absent. This distinguishes it from sibling tools like search_datasets and list_organizations.

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

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

The phrase 'by the id search_datasets returned' implies the tool is used after search_datasets to fetch details for a specific dataset. While not explicitly contrasting with alternatives, the context of sibling tools makes the use case evident.

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 readOnlyHint annotation already covers the non-destructive nature. The description adds the purpose but doesn't disclose behavior such as snapshot semantics, default limits, or return format. With annotations present, this is adequate but not rich.

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

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

A single, efficient sentence that states the resource and its purpose without any wasted words. 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?

With no output schema and no parameter documentation, an agent cannot fully understand how to use this tool correctly. The snapshot-related parameters (as_of, snapshot_id) are especially unclear. The description is too minimal for a tool with three optional 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% and the description mentions no parameters. The schema itself provides only types and constraints, leaving as_of, limit, and snapshot_id unexplained. The description does not compensate for this 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 tool lists publisher names and specifies their intended use in search_datasets' organization parameter. It distinguishes itself from search tools by being a listing operation, though it doesn't name sibling tools explicitly.

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

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

The description implies the primary use case: retrieving valid publisher names for search_datasets. It provides context for when to use this tool but doesn't mention alternatives or when not to use it.

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

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

The description discloses several behavioral details beyond the readOnlyHint annotation: 'Title matches rank first' indicates result ordering, 'description is cut to about 300 characters here' explains truncation, and 'organization is an exact publisher name' plus 'jurisdiction is the source's own word' specify the expected matching semantics. No contradictions with the annotation are 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 concise, consisting of four short sentences, each adding distinct value. It avoids unnecessary verbosity and presents information in a clear, readable manner without requiring a formal structured format.

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

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

Given the tool has 9 parameters and no output schema, the description is incomplete for practical usage. It does not explain return values, pagination, or the meaning of several parameters, nor does it provide enough context to understand how to effectively query datasets. The two explanations provided are helpful but insufficient for a complex search 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?

While the schema has no parameter descriptions, the tool's description explains the semantics of two parameters (organization and jurisdiction) and hints at the query parameter via 'by words in the title, keywords, or description.' Other parameters (as_of, limit, cursor, fields, format, snapshot_id) remain undefined, leaving significant gaps.

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 open.canada.ca datasets by words in the title, keywords, or description.' It is unambiguous and differentiates from sibling tools by focusing on text-based search across specific fields.

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 implicit usage guidance by referencing sibling tools: 'get_dataset returns it whole' suggests using that tool when full descriptions are needed, and 'organization is an exact publisher name from list_organizations' indicates that list_organizations should be queried for valid values. However, it does not explicitly state when to choose this tool over others.

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 readOnlyHint annotation already indicates the tool is non-destructive. The description adds no further behavioral details, such as whether the tool returns cached or live data, or how it handles unavailable services. It meets the baseline but does not exceed it.

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 directly conveys the tool's purpose without extraneous detail. It is well-structured 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 description is sufficient for a parameterless summary tool. It clarifies the output scope (enabled services, coverage, tool names) and the readOnlyHint covers safety. A minor gap is that 'coverage' is somewhat vague, but the overall context is adequate.

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

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

The tool has an empty parameter schema, so there are no parameters to describe. The schema fully covers the input space, making parameter semantics trivial and complete.

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

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

The description clearly states the tool's function: to summarize enabled curated services, coverage, and tool names. It uses a specific verb and resource, and the distinction from sibling tools like search_services or find_capability is evident.

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

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

The description does not explicitly state when to use this tool versus alternatives. It implies an overview use case, but it does not mention that search_services or find_capability would be better for searching/finding specific capabilities, nor does it clarify whether overview is the starting point for discovery.

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 readOnlyHint annotation signals a safe read operation, and the description reinforces this with 'Get' and 'immutable snapshot'. No destructive behavior is implied or described, so there is no 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 brief and front-loaded with the core purpose. The second sentence about citation locators is relevant but somewhat specialized and may distract from the primary retrieval function.

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

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

The description mentions immutable snapshots and citation locators but does not explain expected return content, error behavior, or how the parameters interact. Since there is no output schema and zero schema description coverage, the tool definition leaves important operational context unclear.

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

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

The input schema has no parameter descriptions, and the description does not explain as_of or snapshot_id semantics. document_id is self-explanatory, but the temporal and snapshot-selection parameters remain ambiguous, especially without an output schema to clarify their roles.

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 a single document from an immutable snapshot, giving a specific verb and resource. It is distinct from sibling tools like get_document_changes and search_passages, though the citation-locator sentence adds secondary context.

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

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

The description implies this tool should be used when a specific document ID is known, but it does not explicitly compare against alternatives such as search_passages or list_evidence_sources. The snapshot/citation note hints at usage context but does not provide direct selection guidance.

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

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

The readOnlyHint annotation already indicates a read-only operation. The description adds transparency about a critical behavioral aspect: citation locators are only valid within the snapshot that produced them, and upstream heading insertions can make one edit appear as many changes. This goes beyond the annotation to warn about data interpretation.

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 highly concise: two sentences that front-load the main purpose and then add a relevant caveat. No fluff or redundant information. Every sentence adds value.

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

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

The tool lacks an output schema, and the description does not specify the format or structure of the returned changes (e.g., list of differences with locators). It does provide a helpful caveat about locator validity, but for a tool that returns diff-like data, the absence of any return-type description leaves a notable gap 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?

Schema description coverage is 0% – the description does not explain any of the three parameters (document_id, snapshot_id, as_of). While the names are somewhat self-explanatory, the relationship and precedence between snapshot_id and as_of (e.g., which takes priority) is not addressed. The description does not compensate for the lack of parameter documentation.

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

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

The description clearly states the tool's purpose: 'Compare a document with its prior snapshot.' It uses a specific verb (compare) and resource (document changes), distinguishing it from sibling tools like public-evidence_get_document (fetch document) and public-evidence_search_passages (search passages). No ambiguity.

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

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

The description implies when to use the tool (to see changes between a document and its snapshot) and provides crucial context about snapshot-relative citation locators and the impact of heading insertions. It does not explicitly name alternatives or state 'use this for X instead of Y', but the purpose is clear enough and the caveat helps interpret results correctly.

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 readOnlyHint annotation indicates no destructive side effects, and the description adds useful non-obvious behavior: citation locators are position-based h2/h3 ID fragments and are only valid within the producing snapshot. This goes beyond the annotation, though it does not mention output size, pagination, 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?

Two concise sentences with the main action front-loaded and a relevant caveat afterward. No filler, redundant schema restatement, or unnecessary detail.

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

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

Though the core purpose is stated, the absence of an output schema and the 0% parameter coverage leave important context missing: how topic and fields filter results, what an 'approved source page' is, and how the list relates to snapshots. The citation-locator caveat is useful but does not make the description complete.

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

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

Schema description coverage is 0% and the description does not explain any of the three parameters (limit, topic, fields). It does not compensate for the missing parameter descriptions, leaving an agent to infer semantics solely from names and the fields enum.

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

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

The description states a clear action (List) and object (approved source pages) and distinguishes this from sibling content-retrieval tools like public-evidence_get_document and public-evidence_search_passages. However, 'approved source pages' is not fully defined, and the relationship to evidence snapshots is implied rather than explicit.

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

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

The description does not state when to prefer this tool over siblings or when not to use it. It implies an enumeration/browsing use case but gives no explicit guidance, alternatives, or conditions such as 'use this before searching passages.'

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 readOnlyHint annotation indicates a safe read operation, and the description's 'search' wording aligns with that. However, the description does not disclose return format, pagination behavior, or other side effects, though the annotation covers the main safety aspect.

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 direct, using two sentences without unnecessary fluff. It packs the core purpose and two important contextual notes efficiently.

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

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

Given the lack of an output schema and seven parameters, the description is too sparse. It provides some helpful context about document_id and locators but omits parameter semantics, expected output, and any filtering or sorting behavior, making it insufficient for reliable 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?

The schema has zero parameter descriptions, and the tool description only explains document_id. Parameters such as as_of, limit, query, cursor, fields, and snapshot_id are left entirely undefined, leaving the agent to guess their meaning and usage.

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 searches passages within a single approved document in an immutable snapshot, with a specific verb and resource. It is distinguishable from sibling tools like public-evidence_get_document, though 'approved' is slightly ambiguous without further context.

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

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

The description gives some usage context, such as document_id coming from list_evidence_sources and citation locators being snapshot-specific, but it does not explicitly state when to prefer this tool over related siblings like public-evidence_get_document or public-evidence_list_evidence_sources.

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 readOnlyHint annotation already covers the read-only nature. The description adds useful behavior by stating 'recall is null when absent,' but lacks details on error handling or other edge cases.

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

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

The description is short but poorly structured and grammatically awkward ('One recall by the id search_recalls returned'). This reduces clarity despite its 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?

For a simple get operation, the description provides minimal context. It mentions null behavior but omits information about response structure, potential errors, or the meaning of parameters. The lack of an output schema makes this more critical.

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

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

Schema description coverage is only 40% (2 of 5 parameters described), and the tool description does not compensate by explaining any parameter meanings. recall_id, as_of, and snapshot_id remain ambiguous.

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 indicates retrieving a single recall by its ID, distinguishing it from search and list operations. It mentions the source's advice text, giving a specific 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?

No explicit guidance on when to use this tool versus sibling tools like recalls_search_recalls or recalls_list_categories. The phrasing 'by the id search_recalls returned' is unclear and provides no direct comparison.

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 readOnlyHint annotation is consistent with the read-only nature of listing categories and the description implies no side effects. It does not mention response shape or pagination behavior, but the operation is simple and the annotation covers safety.

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

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

The description is one short sentence with no redundant content, and the title immediately identifies the 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?

The tool is simple and the description connects it to search_recalls, but with several undocumented parameters and no output schema or return-value hint, an agent would still need to infer key details before calling it.

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

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

Only country and subdivision have descriptions; as_of, limit, and snapshot_id are undocumented, and schema description coverage is only 40%. The description does not compensate for these missing parameter meanings.

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?

Title and description indicate the tool lists recall categories from a snapshot, and the note about search_recalls clarifies its purpose. However, the sentence is grammatically awkward and does not explicitly use 'list' or 'return'.

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

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

The phrase 'as search_recalls expects them in category' indicates that the categories are intended as inputs for search_recalls, but it does not explicitly state when to use this tool instead of recalling or searching tools.

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

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

The annotation readOnlyHint=true already covers the read-only nature. The description adds useful behavioral details: active-only filtering by default and field omission behavior. No contradictions with annotations. Missing information about pagination or sorting, but the annotation lowers the bar, and the description adds value.

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

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

The description is concise and well-structured, conveying key information in three short sentences. It avoids verbosity and includes essential usage distinctions.

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 tool's complexity (many parameters, no output schema, multiple sibling search tools), the description only provides partial context. It does not explain the response structure, pagination, or the meaning of most parameters, and only briefly references get_recall for full field details. This leaves significant gaps for an agent trying to use the tool correctly.

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

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

Schema description coverage is only 18% (only country and subdivision have descriptions). The description mentions active_only, category, and fields but does not explain many other parameters such as as_of, snapshot_id, updated_since, cursor, or limit. This is insufficient for an 11-parameter tool with few documented parameters.

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

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

The description clearly states that the tool searches Health Canada recalls and safety alerts by matching words in title, product, or hazard. It also distinguishes itself from recalls_get_recall, 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 provides practical usage guidance, such as the default active-only behavior (unless active_only is false) and that category values should come from list_categories. It also clarifies when to prefer this tool over get_recall regarding the what_you_should_do field, though it does not explicitly enumerate all usage scenarios.

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 readOnlyHint annotation already communicates that the tool is read-only. The description adds that it returns only 'enabled curated' services, but it does not disclose any other behavioral details such as pagination, result ordering, or how query filtering works.

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 unnecessary words. It is front-loaded with the main action and target, 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?

Although an output schema is indicated as present, the description itself does not explain the output structure, pagination behavior, or the semantics of the query parameter. For a search/discovery tool, these details are important for an agent to call it correctly.

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

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

None of the three parameters (limit, query, cursor) are described in the schema, and the description does not compensate by explaining their meaning or usage. This leaves the agent without enough information to use the parameters effectively.

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 action ('Find') and target ('enabled curated services and their tools'). It is specific enough to distinguish it from sibling search tools that target other resource types.

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

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

The description gives no guidance about when to use this tool versus other discovery or meta tools such as 'overview', 'status', 'find_capability', or 'inspect_tool'. There is no mention of scenarios, alternatives, 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?

The description discloses the key behavioral trait that the course is null when absent, which is useful beyond the readOnlyHint annotation. It does not contradict the annotation and adds clarity about the result in a missing-course scenario.

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, front-loaded with the primary action, and contains no extraneous information. The null behavior is stated efficiently in a second clause.

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 retrieval purpose and sufficient parameter descriptions in the schema, the description is reasonably complete. It lacks an explicit output shape, but the null behavior note and schema context cover the main use case.

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

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

The input schema already provides strong descriptions for most parameters, and the tool description does not add significant parameter-level meaning beyond stating the overall retrieval purpose. Schema coverage is high, so the description is adequate but not enhanced.

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

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

The description clearly states the tool gets one course from a snapshot and explicitly defines the null behavior when absent. It is distinguishable from sibling search and listing tools by focusing on single-course retrieval.

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

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

The description implies usage for retrieving a single course from a snapshot, but it does not explicitly mention when to choose this over sibling tools like seneca_search_courses or seneca_get_course_prerequisites. Guidance is present only through inference.

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

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

Beyond the readOnlyHint annotation, the description discloses that text is returned as published and not parsed into eligibility rules, which shapes caller expectations. It also clarifies the provenance as official subject outlines.

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

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

Two short sentences, front-loaded with the core purpose and followed by a key limitation. No redundant wording.

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

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

The description makes clear what the tool returns (raw prerequisite text) and its source, which is the key context absent from the schema. There is no output schema, but the simple return nature is sufficiently conveyed despite the many 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 descriptions cover most parameters (term, as_of, cursor, school_code, snapshot_id, source_code, outline_term_code), and the description adds little parameter-specific meaning. The required course_code and limit/fields lack descriptions, but their purpose is largely inferable from names and enum values.

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

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

States a specific action ('Get raw prerequisite text') and source ('official subject outlines'), clearly distinguishing it from parsing eligibility rules. The sibling set includes multiple Seneca tools, and this one is unmistakably about raw prerequisite text.

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 raw prerequisite text is needed and notes that eligibility rules are not parsed, but it does not explicitly reference alternatives such as seneca_get_course or search tools. No clear when-not or alternative routing is provided.

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

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

The readOnlyHint annotation already indicates a read-only operation, and the word 'List' reinforces this. The description does not add further behavioral details such as pagination or response shape, but those are not required 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 two short sentences with no redundant wording. The key purpose is front-loaded, and the clarifying note about curriculum_semester is placed where it is most useful.

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

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

The description is sufficient for understanding the core operation and the unusual meaning of curriculum_semester. There is no output schema, but the simple list nature of the tool and the parameter descriptions in the schema provide enough context for a caller.

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

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

The description adds meaningful clarification for curriculum_semester, which is not otherwise explained in the schema. Most other parameters already have schema descriptions or are self-explanatory, such as program_code, limit, and fields.

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 a program's curriculum courses, giving a specific verb and resource. It also disambiguates curriculum_semester as a program position rather than a teaching term, which helps distinguish it from other course-related tools.

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

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

The description identifies the basic use case but does not explicitly contrast it with sibling tools such as seneca_search_courses or seneca_get_course. The curriculum_semester clarification provides some usage guidance, but no alternative tools or conditions are mentioned.

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

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

The readOnlyHint annotation already indicates safe read-only behavior. Description adds 'immutable' and result ordering but does not disclose pagination details or other side effects beyond what the annotation covers.

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, concise sentence with no redundant wording. Clearly states purpose and key attributes without 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?

Adequate for a simple list operation, but lacks details on default fields, pagination behavior, and how 'current first' is determined. The absence of an output schema is not overly problematic but could benefit from a note.

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?

Only cursor and source_code have descriptions; limit and fields lack explanations in the schema. The description's 'for one source' hints at source_code but does not clarify fields or limit semantics.

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

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

Clear verb 'List' with specific resource 'immutable catalog snapshots' and scope 'for one source' distinguishes it from sibling search/list tools. The ordering 'current first' adds specificity.

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

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

Implies use when listing snapshots for a particular source, but does not explicitly differentiate from sibling tools like seneca_list_sources or search variants. No 'when to use' or alternative guidance given.

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

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

The readOnlyHint annotation already covers the read-only nature, so the description does not need to repeat that. However, it provides no additional behavioral context such as pagination behavior, response format, or whether results are ordered. The description adds nothing beyond the annotation and leaves the agent guessing about the output structure.

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 extraneous words. It is front-loaded with the core purpose and is appropriately sized for a simple list operation. There is no redundancy or filler.

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

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

The description is incomplete for an agent to correctly invoke the tool. It does not state what fields are returned by default, how the 'fields' parameter interacts with the response, or whether results are paginated. The naming inconsistency between 'sources' and 'institutions' further complicates usage. Without an output schema or additional guidance, an agent may not know what to expect from the response.

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

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

Schema description coverage is 0%, so the description must explain the parameters. It does not mention 'limit' or 'fields' at all, nor their effects. The agent must infer from parameter names, which is risky. This is a significant gap because the tool has two optional parameters that control result count and field selection.

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

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

The description states a clear verb and resource: 'List the institutions available in this catalog.' It distinguishes this tool from siblings like seneca_list_snapshots and seneca_search_courses by focusing on institutions. However, the tool name says 'sources' while the description says 'institutions,' which could cause minor confusion, so it loses a point.

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. It does not mention that this is the go-to for enumerating institutions, nor does it reference any sibling tool or scenario where another list/search tool would be preferred. The description is purely declarative with no context for 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?

The readOnlyHint annotation already establishes the read-only nature, and the description is consistent with that, describing a search operation. No contradiction exists, though the description adds no additional behavioral detail such as pagination or side effects.

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

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

The description is a single focused sentence with no redundant or extraneous content. It communicates the core purpose clearly and efficiently.

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

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

The description adequately conveys the tool's purpose and scope, and the parameter schema supplies most of the remaining context. The lack of an output schema is not a major issue for a search tool, though return shape and pagination behavior are not explicitly stated.

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?

Several parameters have useful descriptions (term, as_of, cursor, snapshot_id, source_code), but the required query parameter is undescribed, and limit and fields lack semantic explanation. Schema coverage is 63%, so the description only partially compensates for parameter ambiguity.

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

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

Description clearly states a specific action ('Search'), a specific resource ('courses'), and a clear scope ('within one snapshot'). It distinguishes this from related tools like seneca_get_course or seneca_search_programs.

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

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

The intended use as a search operation over courses is implied, but no explicit guidance is given about when to prefer this over sibling tools such as seneca_get_course or seneca_search_programs, nor any exclusions or alternative recommendations.

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

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

Annotations already provide readOnlyHint=true, so the description doesn't need to repeat that. It adds the 'one catalog snapshot' scope, which is useful context beyond the schema. However, it doesn't disclose pagination behavior, result shape, or any other behavioral traits, so it adds only marginal value over the annotations.

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

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

A single sentence with no fluff. The core action and scope are front-loaded. It's appropriately concise, though it could include a bit more detail without losing 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?

With 8 parameters, no output schema, and no mention of return format or pagination, the description is insufficient for an agent to fully understand the tool's behavior. The 'one catalog snapshot' is helpful but doesn't cover the full context needed for correct invocation, such as how to specify a snapshot or interpret results.

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 63%, meaning about 37% of parameters are undocumented in the schema. The description only hints at 'program codes or names' which relates to query and possibly fields, but it doesn't explain term, as_of, limit, cursor, snapshot_id, or source_code. Since coverage is moderate and the description doesn't compensate for the gaps, it adds little 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 states a clear verb 'Search' and resource 'program codes or names', and adds the scope 'within one catalog snapshot', which helps differentiate from sibling search tools like seneca_search_courses. However, it doesn't explicitly name any sibling or elaborate on the difference, so it's clear but not fully distinct.

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 vs alternatives. It implies a single-snapshot scope but doesn't mention that seneca_list_snapshots or seneca_search_courses might be more appropriate for other scenarios. There are many sibling search tools, and without explicit conditions, an agent may pick the wrong one.

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 readOnlyHint annotation is present and the description ('Report') aligns with read-only behavior. No additional behavioral details are needed for a simple status query.

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, concise and directly to the point. No extraneous words or vague phrasing.

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?

Description adequately conveys the purpose and the kind of information returned (freshness, last success/failure, staleness). Output schema is indicated as present, so not detailing structure here is acceptable.

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

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

No parameters exist, and schema coverage is 100% (empty schema). The description adds no parameter information because none are needed.

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

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

Clearly states the action (Report) and the specific resource (freshness of every enabled curated service), including details about last success, last failure, and staleness. Distinct from all sibling tools which are get/search/list operations.

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

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

Description explains what the tool does but provides no explicit guidance on when to use it versus alternatives. However, the purpose is self-evident as a status check, so it doesn't create confusion.

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 readOnlyHint annotation already indicates no side effects, and the description adds useful behavioral context about the envelope indicating whether the capture is fresh or the feed was unavailable. No contradictions are 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 concise, uses two short paragraphs, and avoids unnecessary detail. All information is relevant and presented clearly without redundancy.

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

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

With seven optional parameters, no output schema, and only one parameter described in the schema, the description leaves significant gaps. It mentions the envelope but does not describe the overall response shape, pagination via cursor, field selection, or snapshot filtering, making it incomplete for fully informed usage.

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

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

Schema description coverage is only 14%, with only 'agency' described as 'Only ttc is supported'. The description elaborates on 'route' but leaves as_of, limit, cursor, fields, and snapshot_id unexplained. Given the low schema coverage, the description does not sufficiently compensate.

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

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

The description clearly states the tool returns current TTC service alerts for subway, streetcar, bus, and elevators from the last capture. It distinguishes itself from sibling tools like transit-toronto_get_routes by focusing on alerts rather than route listings.

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

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

The description provides some guidance on the 'route' parameter and mentions the envelope's freshness indicator, but it does not explicitly state when to use this tool versus alternatives such as transit-toronto_get_routes or transit-toronto_list_agencies. Usage is implied rather than explicitly contrasted.

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 readOnlyHint annotation already covers side effects, and the description adds some behavior context by specifying the returned routes are alert-related. However, it does not explain capture semantics, pagination, or other runtime 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 short and contains no filler, but it is telegraphic and relies on the reader knowing what 'capture' and 'as get_alerts expects them in route' mean.

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

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

The description gives some idea of the output but is incomplete for a tool with 4 optional parameters and no output schema. It does not explain how the parameters affect results, what a 'capture' is, or what the returned route data looks like.

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?

Only 1 of 4 parameters has a schema description, and the tool description does not explain as_of, limit, snapshot_id, or their roles. The description adds no parameter-level meaning beyond the minimal agency note.

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 identifies routes as the resource and adds a useful filter ('at least one alert in the capture'), plus a relationship to get_alerts. It lacks an explicit verb, but the tool name and sibling context make the action clear.

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

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

The phrase 'as get_alerts expects them in route' implies this tool is meant to feed route values into get_alerts, but it does not explicitly state when to use this tool versus alternatives or when not to use it.

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

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

The readOnlyHint annotation covers the read-only behavior, and the description adds the useful caveat 'Only the TTC today', but it does not describe what the tool returns or how it behaves when no agencies exist.

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

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

The description is very brief and contains no filler. It efficiently communicates the core scope, though it is a fragment rather than a full sentence.

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 minimal schema and no output schema, the description is too sparse to be fully self-contained. It omits parameter semantics and usage guidance, leaving an agent to infer how to call the tool and interpret results.

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 provides no meaning for the 'limit' or 'fields' parameters. The parameter names hint at their purpose, but the description does not 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 title indicates 'list agencies' and the description says 'The transit agencies covered', which is fairly clear but lacks an explicit verb and does not differentiate from sibling tools like transit-toronto_get_routes or transit-toronto_get_alerts.

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 about when to use this tool versus alternatives such as getting routes or alerts. The description only states scope, not usage context 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?

The readOnlyHint annotation already communicates that this is a read-only operation, and the description adds the important null-when-absent behavior. There are no side effects or hidden writes described.

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 short and front-loaded with the core purpose and null behavior. The wording is slightly awkward ('by the id search_weather_alerts returned') but it contains no unnecessary detail.

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

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

For a simple single-object lookup with no output schema, the description conveys the main success and not-found outcomes. Mentioning the alert object shape would improve completeness, but it is not essential for basic 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?

The schema description coverage is only 40%, and the tool description provides no additional parameter semantics. alert_id and subdivision are reasonably self-explanatory, but as_of and snapshot_id are not described at all.

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 that the tool returns one alert by ID and that the alert is null when absent. It distinguishes this from the related search tool by focusing on single-alert retrieval.

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

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

The description implies that the alert ID comes from search_weather_alerts and clarifies null behavior when the alert is missing. It does not explicitly say 'use this after search_weather_alerts', but the retrieval-by-ID intent is clear.

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

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

The readOnlyHint annotation already covers the read-only nature of the tool. The description does not add any further behavioral details such as whether it reads from a snapshot or how it handles missing data, but since annotations are present, the bar is lowered.

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 unnecessary words or repetition. It directly communicates the tool's purpose without overcomplicating.

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 five parameters and no output schema, the description is too sparse to be contextually complete. It fails to explain what the response looks like, the meaning of several parameters, or how the snapshot context affects the data, leaving significant gaps for the 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?

Only 40% of the parameters have descriptions in the schema (country and subdivision), and the tool description adds no additional meaning to any parameter. It does not clarify what as_of, limit, or snapshot_id do, leaving the agent with insufficient information to use them correctly.

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 alert types (watch, warning, statement) for a province, which distinguishes it from searching for alerts or getting a specific alert. However, it does not explicitly contrast with sibling tools like search_weather_alerts, so it lacks some sharp differentiation.

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

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

The description gives no explicit guidance on when to use this tool instead of alternatives such as search_weather_alerts or get_weather_alert. The intended use case is only implied by the wording, leaving the agent to infer when listing types is appropriate.

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

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

The readOnlyHint annotation already covers safety, and the description adds meaningful behavioral details such as default active-only filtering and ordering. However, it does not describe return format, pagination, or how filters like fields, cursor, or snapshot_id affect results.

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 and front-loaded, immediately stating the core behavior and the required subdivision parameter. The additional sentence about alert_type and active_only is relevant and adds value without unnecessary verbosity.

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, no output schema), the description is incomplete. It does not explain the output structure, pagination, or the meaning of many parameters, leaving significant gaps for an agent attempting to use the tool correctly.

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

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

Schema description coverage is only 18%, with only country and subdivision having direct descriptions. The main description adds context for alert_type and active_only, but many parameters (as_of, query, cursor, fields, risk_colour, snapshot_id) remain unexplained, leaving the agent without sufficient guidance for their intended use.

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: to search active ECCC weather alerts for one province or territory, sorted newest first. It explicitly identifies the resource (weather alerts), the action (search), and the scope (per province), making it easy to distinguish from the related get_weather_alert and list_weather_alert_types siblings.

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

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

The description does not provide explicit guidance on when to use this tool versus the sibling get_weather_alert or list_weather_alert_types tools. It implies usage for listing/searching alerts by province but gives no direct comparison or exclusion criteria.

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