opportunity-exchange

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

With no annotations provided, the description carries full burden and does so thoroughly. It discloses that it returns only compatibility, is inferred, never reads withheld capabilities, and explicitly lists what it does not establish, providing clear behavioral expectations.

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 three concise sentences: the first states the core action, the second clarifies scope and limitations, and the third directs to an alternative. Every sentence earns its place; no fluff or redundancy.

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

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

Despite having no output schema and no annotations, the description provides complete context: it explains the return type, limitations, and alternative tool. It effectively covers the behavioral and usage semantics needed for an agent to decide when and how to use it.

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

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

Schema description coverage is 100%, so the input schema already documents all parameters (limit, businessId, includeHistory) with descriptive text. The description adds no additional parameter-specific meaning, warranting the baseline score.

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

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

The description uses a specific verb ('Compare') and clearly identifies both resources: published supply categories and UNSPSC categories official buyers requested. It explicitly states the output is category compatibility only, classed as inferred_compatibility, which distinguishes it from sibling tools like inspect_procurement_activity.

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

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

Provides explicit alternative guidance: 'Use inspect_procurement_activity for the buyer-side observations themselves.' Also clarifies when not to use this tool by stating it establishes no qualification, eligibility, supplier relationship, competitiveness, or likelihood of award, effectively setting exclusion conditions.

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

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

With no annotations, the description carries the full burden of behavioral disclosure. It clearly states that advertised record counts are counts of advertisements, not unfilled positions or people needed, and that they are not deduplicated across employers. It also discloses that the tool deliberately avoids combining metrics into a shortage claim, providing critical context for interpreting outputs.

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

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

Three sentences, each adding critical information: what is reported, what is not claimed, and how to interpret counts. No filler or redundancy; the description is front-loaded with the core action.

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

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

The description covers the tool's scope and data caveats well for a simple one-parameter tool with no output schema. It could add more detail on the 'training-route constraint indicator' or the response structure, but it remains highly serviceable and complete enough for an agent to select and invoke the tool correctly.

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

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

The input schema has a single parameter 'limit' with a complete description ('Maximum rows per view; default 50'), so schema coverage is 100%. The tool description adds no parameter-specific semantics, meeting the baseline 3 for high schema coverage.

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

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

The description uses the specific verb 'Report' and lists four distinct output components (occupational demand, credential demand, training availability, training-route constraint indicator). It distinguishes itself by emphasizing 'separately' and explicitly stating it does not combine them into a shortage claim, clearly separating it from sibling tools that might conflate demand metrics.

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 an explicit when-not: it is not suitable for making shortage claims because that requires a credential-holder denominator OEX lacks. However, it does not name alternative tools or give positive use cases, so it stops just short of full alternative guidance.

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

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

With no annotations provided, the description carries full responsibility and delivers: it explicitly states no account, no storage, no record creation, and that OEX asserts nothing and holds no record. This is exceptional transparency about side effects and data handling.

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

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

Three tightly constructed sentences, each carrying unique information: what the tool does, when to use it, how to improve results, what it doesn't do, and the alternative. No filler.

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

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

Given no output schema and no annotations, the description covers the essential aspects: use case, conditions, effect on business, website importance, and alternative. It is fully self-contained for an agent to decide when and how to invoke it.

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

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

Schema description coverage is 67%, so the schema already documents most parameters. The description adds value by highlighting the website parameter ('Worth supplying — eight checks depend on it') and explaining that the report reflects the provided details and named site, going beyond the schema.

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

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

The description opens with a specific verb+resource: 'Run Business Health on a real business from details you supply,' and distinguishes itself as 'the free public check.' It contrasts with create_sandbox_business, making the differentiation from sibling tools 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?

Provides clear when-to-use guidance: 'Use this when someone asks about *their own* business,' and specifies conditions (no account, stores nothing, creates no record). It also names the alternative tool for experimentation: 'use create_sandbox_business.'

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

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

No annotations are provided, so the description carries the full burden. It discloses that the tool returns explicit reasons for incompatibility, which is useful. However, it does not state whether the operation is read-only, what the successful return looks like, or whether it checks pairwise or all entities at once. This leaves some ambiguity.

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

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

The description is a single sentence, directly front-loaded with the action verb, and includes no filler. It efficiently conveys both what is checked and the output 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?

With no annotations and no output schema, the description provides the core purpose and mentions the output (explicit reasons). It does not explain the structure of those reasons or the behavior when inputs are compatible, but the schema covers parameter types. For a validation tool, this is reasonably complete.

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

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

The input schema already has detailed descriptions for all three parameters (100% coverage). The description adds context by linking the check criteria (concepts, units, etc.) to the requested observations, making it clear how entities and metrics are used. While it doesn't describe each parameter individually, it enhances understanding of the tool's purpose.

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 with the verb 'Check' and specifies the resource ('requested community observations') and the specific compatibility dimensions (concepts, units, geographic boundaries, reference periods). It also states the output (explicit reasons). This differentiates it from sibling tools like compare_communities which likely perform actual comparisons.

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 is a preliminary validation step for comparison but does not explicitly state when to use it over alternatives. No exclusions or when-not-to-use guidance is provided. The sibling list suggests it should be used before compare_* tools, but this is not stated.

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

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

With no annotations, the description carries the full burden. It discloses a valuable behavioral trait: the tool returns explicit missing-data and comparability results for every metric, which goes beyond a simple comparison. However, it does not mention permission requirements, output format, or how errors are handled, leaving notable gaps.

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

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

The description is a single, front-loaded sentence that conveys the essential purpose, scope, and a key output trait. It is free of fluff and every word contributes meaning.

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 annotations and output schema, the description provides only a high-level understanding. It explains that the tool returns missing-data and comparability results but does not detail the structure of the results or edge cases such as invalid entity names. This is adequate but not comprehensive.

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

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

Schema coverage is 100%, so the baseline is 3. The description adds no new parameter-specific details beyond what the schema already provides. It references 'requested metric' which aligns with the metrics parameter, but does not elaborate on valid metric names or behavior.

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: compare 2-10 Saskatchewan communities. It specifies the geographic scope (Saskatchewan) which distinguishes it from broader tools like compare_municipalities, and reveals a specific output characteristic (explicit missing-data and comparability results) that differentiates it from generic comparison 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 provides clear context for when this tool is appropriate: whenever a comparison of Saskatchewan communities is needed, with 2-10 entities and explicit missing-data handling. However, it does not explicitly mention alternatives or exclusion criteria, so it stops short of a 5.

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

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

With no annotations provided, the description carries the full burden. It adds useful behavioral traits: uses the 'newest governed fact,' requires matching units and reference periods for comparability, and explicitly returns missing/mismatched evidence. It does not disclose output format or access requirements, but for a comparison tool these are less critical.

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

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

The description is two sentences, front-loaded with the primary purpose, followed by the key behavioral constraint. Every word earns its place, with no repetition of schema details or annotations.

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 no output schema and no annotations, the description covers the core aspects: what it does, the condition for comparability, and how missing/mismatched evidence is returned. It lacks a description of the successful return format, but this is partially mitigated by the tool's clear purpose.

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 100% coverage with meaningful descriptions for all three parameters (entities, bundle, metrics). The description adds minimal parameter-level meaning beyond reinforcing the idea of 'standard economic metric' and 'resolved municipalities,' both already implied by the schema, so the baseline of 3 applies.

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

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

The description states a specific action: 'Compare 2–10 exact Saskatchewan municipalities using the newest governed fact for each standard economic metric.' This clearly identifies the verb (compare), resource (municipalities), and scope (Saskatchewan, 2–10), distinguishing it from sibling tools like compare_outcomes or compare_roles.

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

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

It provides clear context for when to use the tool, namely comparing multiple Saskatchewan municipalities on economic metrics. It also specifies the comparability condition (same unit and reference period) and explicitly notes how missing/mismatched evidence is handled, but it does not mention alternatives or when not to use the tool.

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

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

No annotations are provided, so the description must fully disclose behavior. It explains the core computation but omits details like whether it is read-only, requires authentication, or has limits. The mention of 'meta.evidence' is vague.

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, information-dense sentence. It could be more clearly structured (e.g., separate sentences for purpose and parameter guidance), but it conveys the essential meaning 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 no output schema, the description should explicitly state what the tool returns (e.g., list of communities with leftover amounts). It only implies the output. Also, it does not clarify that both parameters are optional but at least one is needed, creating ambiguity.

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

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

The input schema already describes both parameters. The description adds that occupation models median wage and mentions 'meta.evidence', providing mild extra context, but does not fully explain the 'role id' format or how wage is used.

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 computes disposable income after costs like tax, housing, and commuting, specific to Saskatchewan communities. This distinguishes it from siblings like get_wages or get_real_estate, though the phrasing 'wage-vs-cost join' is slightly opaque.

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 vs alternatives. It only explains that either occupation or wage must be passed, but does not clarify scenarios where one is preferred or warn against using it for other purposes.

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

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

No annotations are provided, so the description carries full burden. It does not disclose behavioral traits such as read-only nature, real-time data status, authorization needs, rate limits, or any side effects. The description only states what the tool does, not its operational characteristics.

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

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

The description is a single sentence that is concise and front-loaded with the tool's purpose. No redundant words; every phrase contributes to understanding.

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

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

Given no output schema, the description should explain the format of the comparison result, but it does not. It also does not clarify the relationship to sibling comparison tools. However, the tool is simple and the description covers the basic purpose and 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 100% for the single parameter 'ids'. The description adds meaningful context by listing the specific fields used for comparison (wages, demand, etc.), which is not in the schema. This enhances understanding beyond the parameter description.

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

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

The description clearly states the verb 'compare' and the resource 'roles', and specifies the fields used: wages, demand, outlook, entry requirements, and work profile. It distinguishes from siblings like 'compare_outcomes' and 'evaluate_pathways' by focusing on role comparison with occupation 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?

No explicit guidance on when to use this tool versus alternatives like 'compare_outcomes' or 'evaluate_pathways'. The description does not provide conditions, prerequisites, or exclusions. The schema hints that IDs come from 'list_roles', but that is minimal.

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

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

With no annotations provided, the description carries full burden and does well: discloses the synthetic nature, return of id, non-visibility in public listings, and the effect of leaving fields out. This is rich behavioral context.

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

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

Four concise, front-loaded sentences. 'Start here' immediately signals usage, and each subsequent sentence adds essential context without redundancy or fluff.

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

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

For a create tool without output schema or annotations, the description covers return value, purpose, visibility, and parameter usage. It could mention how to locate the created business later (e.g., via list_sandbox_businesses), but sibling tools imply that.

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

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

Schema description coverage is 100%, so the baseline is 3. The description adds value by explaining that parameters can be set to whatever the scenario needs and that omitted fields produce gaps, enhancing the meaning beyond the schema.

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

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

The description uses a specific verb 'creates' and resource 'synthetic business', clearly states it returns the id, and distinguishes itself as the starting point for Business Health sandbox workflows.

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

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

Explicitly states 'Start here to try Business Health', indicating when to use. It also explains how omitting fields creates gaps, but does not mention explicit 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?

With no annotations, the description details the return format (pass/conflict/unknown and evidence panel), non-storage of request data, and exclusion of OSINT/placeholders. It lacks explicit assurances of read-only nature or authentication needs, but the information provided is clear.

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 three sentences, efficient and focused. The first sentence is long but lists all inputs. Some repetition of 'same...panel' could be condensed, but overall it's well-structured.

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

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

Given 16 parameters, no output schema, and no annotations, the description adequately summarizes inputs and outputs but does not explain ranking logic or evidence panel contents, leaving gaps in understanding.

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

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

Schema description coverage is 100%, so baseline is 3. The description only summarizes parameter categories without adding new constraints or examples, providing no extra value beyond the schema.

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

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

The description clearly states the tool evaluates realistic routes into work based on detailed personal and contextual inputs, and distinguishes from sibling tools like 'compare_roles' or 'list_roles' by focusing on pathway evaluation.

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 evaluating pathways but does not explicitly compare to alternatives or state when not to use. Guidance like 'OSINT and placeholder values excluded' is helpful but not comprehensive.

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

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

With no annotations provided, the description carries the full burden. It discloses the topics covered but does not explain behavioral aspects such as the optional 'confidence' parameter, what happens when it is omitted, or the output format. For a tool that likely produces explanation text, this lack of detail about invocation behavior is a notable gap.

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

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

The description is a single, well-structured sentence that front-loads the verb and resource. It is dense with relevant information and contains no filler or redundancy, achieving maximum efficiency.

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

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

For a simple tool with one optional parameter and no output schema, the description covers the core purpose but misses key context: how to use the parameter and what kind of answer to expect. It is minimally acceptable but not complete enough to fully guide an agent without additional inference.

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

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

Schema description coverage is 0% and the description does not mention the 'confidence' parameter at all. Since there is one optional enum parameter, the description should clarify whether providing a value limits the explanation to that level or explains the entire vocabulary. It does not, leaving the parameter's effect 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 states a specific verb ('Explain') and a specific resource ('the OEX A–D record-confidence vocabulary'), and further details the content ('weakest-input rule for derived values', 'interpretation contract'). This distinguishes it from sibling tools that retrieve or compare data, making the purpose clear and unique.

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 one needs to understand confidence levels, but it does not explicitly state when to use this tool versus alternatives like 'explain_truth_state' or when not to use it. There are no exclusions or alternative references, so guidance is only implicit.

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

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

With no annotations, the description is the sole source of behavioral information. It hints at an explanatory output but does not disclose whether the operation is read-only, what side effects exist, or how invalid truthState values are handled. The 'complete interpretation contract' is mentioned but not defined.

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

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

The description is a single concise sentence that front-loads the primary verb. It avoids unnecessary words, though it sacrifices informational content for brevity.

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

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

For a tool with one parameter, no output schema, and no annotations, the description should clarify the domain-specific concepts (e.g., what counts as a truth state, what the interpretation contract contains). It does not, leaving the agent to guess the meaning of the enum values and the structure of 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?

The schema provides an enum of six truthState values, but the description gives zero parameter information. It does not explain the meaning or effect of each enum value, nor whether the parameter is optional despite being non-required in the schema. There is no compensation 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 identifies a specific task: explaining what an OEX truth state permits and returning an interpretation contract. The verb 'explain' plus unique resource 'OEX truth state' distinguishes it from many sibling tools, though it doesn't explicitly contrast with 'explain_confidence'.

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

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

No guidance is provided on when to use this tool versus alternatives like explain_confidence or other query tools. The description lacks any context about prerequisites, comparisons, or exclusions.

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

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

Despite having no annotations, the tool definition provides meaningful behavioral details: depth describes the addition of an expansion block with hop annotations, and limit/maxNodes explicitly distinguish per-level bounds vs whole-expansion ceilings. The description itself mentions 'governed' predicates and output annotations, which adds context about data quality and result structure. However, it does not state whether the operation is read-only or if any authentication/permission constraints apply, leaving some burden unmet.

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

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

The main description is a single sentence that immediately conveys the core purpose and key output attributes, placing the most important information upfront. The parameter descriptions are verbose but densely useful, with no filler. The structure is clean and front-loaded.

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

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

The tool has 13 parameters, no annotations, and no output schema, so the description must carry more weight. The parameter descriptions explain key behaviors (expansion, limits), but the overall response shape is under-specified: the phrase 'with source, truth state, confidence, and hop annotations' hints at the output, but it remains unclear whether results are a flat list, nested graph, or node/edge blocks. Error scenarios and default behavior when no entity is given are also not addressed.

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 85% (11 of 13 parameters have descriptions), so the baseline is 3. The main description does not add much parameter-level meaning; it echoes 'truth state' and 'confidence' but does not clarify the 'truthStates' or 'minimumConfidence' parameters, both of which lack schema descriptions. Some parameter descriptions (depth, limit, maxNodes) are rich and provide practical context, but this is primarily from the schema, not the tool description.

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

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

The description uses a specific verb ('Find') and resource ('entities connected through governed graph predicates') and further defines the result by naming source, truth state, confidence, and hop annotations. This distinguishes it from sibling tools like get_entity, search_entities, and find_potential_customers, which target single entities, free-text search, or specialized relationships.

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 main description does not explicitly compare this tool to alternatives, but the name and phrase 'connected through governed graph predicates' imply graph traversal as the intended use. Parameter descriptions in the schema (e.g., depth's example of fetching containment chains in one call) hint at use cases, but there is no explicit when-to-use or when-not-to-use guidance relative to similar siblings like query_knowledge_graph or traverse_relationships.

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

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

With no annotations, the description carries the full burden and does well by disclosing non-obvious behavior: results are only potential compatibility, target businesses expressed no interest, industry is not matched, and withheld categories are excluded. It does not discuss auth, errors, or rate limits, but it provides substantial interpretive context.

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

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

The description is three dense, front-loaded sentences. Every sentence contributes non-redundant meaning: what it finds, what it returns, what it does not do, and matching exclusions. No waste.

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

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

Given a single parameter and no output schema, the description explains the meaning of the result and key limitations. It could specify exact return fields, but 'Returns potential_compatibility only' and the exclusions provide enough context for correct selection and invocation.

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

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

Schema coverage for the single parameter is 100%, and the schema already explains businessId with format, example, and source. The description adds no additional parameter-level detail, so the baseline score of 3 applies.

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

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

The description opens with a specific verb and resource: 'Find businesses whose published purchasing categories match the categories a business has published as things it can supply.' It clearly distinguishes the tool from a customer list and from industry-based matching, making its purpose unambiguous.

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

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

The description implies when to use the tool (when assessing supply/purchase category compatibility) but does not explicitly state when not to use it or name alternatives such as find_potential_suppliers. The 'not a customer list' caveat helps interpretation but does not provide explicit tool-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?

With no annotations provided, the description takes full responsibility for behavioral disclosure. It transparently explains that the result is only a potential compatibility signal, no relationship is asserted, neither party may be aware of the other, and withheld categories are excluded. This is rich beyond what any schema or annotation would provide, addressing the tool's limitations and semantic meaning.

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 three sentences, each earning its place: first states the action, second clarifies output semantics, third lists exclusions. It is front-loaded and contains no redundant or filler 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?

For a tool with one parameter, no output schema, and no annotations, the description covers purpose, result semantics, and exclusions well. It explains what the output means ('potential_compatibility only') but does not explicitly describe the return structure (e.g., list of businesses with scores). This minor ambiguity prevents a perfect score.

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

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

The single parameter businessId is fully documented in the schema with type, format ('business:<canonical-id>'), and source ('from resolve_entities'). Schema coverage is 100%, so the description needs no additional parameter info. The description adds no extra parameter semantics beyond the schema, so baseline 3 applies.

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

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

The description clearly states the tool's function: 'Find businesses whose published supply categories match the categories a business has published as things it buys.' This is a specific verb+resource+scope statement. It distinguishes itself from the sibling 'find_potential_customers' by focusing on supply-side matching, and further clarifies what it does not do ('Nothing is matched on industry').

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

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

The description clearly implies the use case: when a user wants to identify potential suppliers for a given business based on category compatibility. It does not explicitly contrast with find_potential_customers or state exclusions, but the behavior is self-explanatory and context is clear. A minor gap is the lack of explicit 'when not to use' guidance.

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

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

With no annotations, the description carries the transparency burden. It adds a behavioral caveat: 'Licence presence establishes snapshot presence only,' which hints at data interpretation nuances. Yet it omits auth requirements, error behavior, or return format, so transparency is incomplete.

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 with two sentences and no filler. The first sentence states purpose clearly. The second sentence is cryptic but not wasteful, though clearer wording would improve understandability.

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, so the description should explain what data is returned. It mentions 'governed context and evidence boundary' without elaboration, leaving the return structure and possible edge cases (e.g., missing entity) undefined. This is insufficient for a tool with no structured output metadata.

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

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

Schema coverage is 100% as the only parameter 'id' has a descriptive explanation ('Canonical business id from search_businesses or a graph query'). The description itself adds no extra parameter semantics, matching the baseline for high schema coverage.

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

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

The description clearly states the tool retrieves 'governed context and evidence boundary' for a single business entity, which is a specific verb+resource. However, it doesn't explicitly differentiate from sibling tools like get_evidence or get_entity_context, though the business entity scope provides some distinction.

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

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

The description implies usage when you need evidence context for a business entity, and the id parameter description in the schema says to source IDs from search_businesses or graph queries. However, there is no explicit when-to-use guidance or mention of alternative tools, leaving usage partially implied.

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

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

With no annotations, the description carries the burden of disclosing behavior. It clarifies that the headline is categorical and that OEX publishes no numeric score, which is useful. However, it does not explicitly state that the operation is read-only, describe error scenarios, or mention side effects, leaving gaps.

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

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

The description is two sentences long, with the first sentence listing the report components and the second adding a key clarification about the categorical headline. Every word adds value, and the most important information is front-loaded.

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

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

Given the simple schema (one required parameter) and lack of output schema, the description covers the main return contents and an important behavioral fact. It does not address error handling or alternative tools, but for a straightforward getter, it is fairly 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%, so the description must compensate. It adds that the businessId refers to a 'sandbox business', which is meaningful, but it does not provide format, source, or constraints. The single parameter remains underdescribed.

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 'the full health report for a sandbox business' and enumerates its contents (headline, findings, invitations, passed, not evaluated). This distinguishes it from siblings like check_business_health and get_business_health_markdown, and the note about no numeric score 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?

The description implies usage when a complete health report is needed, but it does not explicitly state when to prefer this over sibling tools like check_business_health or get_business_health_markdown. No direct alternatives or exclusions are mentioned, so guidance is only implicit.

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

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

With no annotations provided, the description carries the full burden, but it only conveys format and intended audience, not behavioral traits such as read-only nature, data sources, or side effects. It does not disclose what the report contains or any important behavioral details.

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

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

The description is a single concise sentence with no fluff. It uses an em dash to efficiently explain the use case. However, it is somewhat ambiguous due to the reference to 'the same report,' so it does not earn a 5.

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

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

For a tool with one parameter and no annotations, the description is too vague. It does not explain what the report contains, how to interpret the markdown, or any prerequisites such as consent or existing health data. It relies heavily on the reader understanding 'the same report' and the business 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 has one parameter businessId with zero description coverage (0%). The description does not mention the parameter at all, providing no additional meaning beyond the parameter name. It fails to compensate for the lack of schema description.

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

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

The description says 'The same report as markdown' without identifying what report, relying on the tool name for context. It is not a tautology since it adds format and intended use, but it lacks an explicit verb and resource. It vaguely distinguishes from siblings by noting it is the markdown form, but does not name the sibling.

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

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

The description implies usage when a markdown version of a business health report is needed, specifically for handing to a website maintainer. However, it does not explicitly state when to use this tool versus alternatives like get_business_health, nor does it provide exclusions or name alternatives. The usage is implied rather than 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?

No annotations are provided, so the description carries the full burden. It discloses the return structure (central estimate, range, sector shares, or suppression reason) and implies read-only behavior. However, it does not mention authentication, rate limits, or data freshness, which would be ideal.

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

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

The description is two sentences, front-loaded with the core purpose and details. No unnecessary words; 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?

Despite no output schema, the description explains the response format thoroughly (central estimate, range, sector shares, suppression reason). It also tells where to obtain valid codes. For a single-parameter read tool, this is complete.

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

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

Schema coverage is 100%, so baseline is 3. The description adds a concrete example (4708004 for Swift Current) and explains the format (7-digit 2021 SGC code), providing value beyond the schema.

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

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

The description clearly states the tool retrieves a community's GDP report by census code, including central estimate, range, sector shares, or suppression reason. This distinguishes it from sibling tools like get_economy_overview, which provides an overview of codes.

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

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

The description indicates that codes come from get_economy_overview or an API endpoint, implying when to use this tool (after obtaining a specific code). It does not explicitly state when not to use it or name alternatives, but the context is clear enough.

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

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

No annotations are provided, so the description carries the full burden of behavioral disclosure. It mentions that the profile is 'governed' and includes 'qualifications', which hints at data governance and vetting, but it does not disclose potential errors, response shape, or operational behaviors such as required permissions or rate limits. The read-only nature is implied by 'Retrieve', but not elaborated.

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

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

The description is a single, front-loaded sentence that immediately states the verb and resource. It avoids unnecessary words and is easy to scan. Every word contributes to describing the tool's purpose.

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

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

The tool has one parameter and no output schema, but the description provides a brief overview of what the profile contains. However, given the lack of output schema and annotations, a more complete description might include examples of the return structure or clarify what 'governed' means in practice. The description is sufficient for a simple retrieval tool but leaves some gaps.

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

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

Schema description coverage is 100% for the single parameter 'id', which is described as 'Municipality name, slug, or SGC code.' The description of the tool adds no additional parameter semantics beyond what the schema already provides. Since the schema does the heavy lifting, the baseline score of 3 is appropriate.

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

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

The description uses a specific verb 'Retrieve' and clearly identifies the resource as 'one municipality as a governed economic profile'. It lists profile components (canonical identity, available evidence, links, qualifications), which gives some differentiation from sibling tools like get_community_economy or get_economy_overview. However, it could more explicitly state what makes 'governed economic profile' unique, so it does not fully distinguish itself.

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

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

The description provides no guidance on when to use this tool versus alternatives. There are no exclusions, no mention of when a sibling tool would be more appropriate, and no context about prerequisites or intended use cases. It only states what it does.

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

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

With no annotations, the description carries the full burden. It discloses the operation is read-only and explains the grouping and eligibility for factual claims. This adds meaningful context beyond the empty schema, though details like return format or pagination are missing.

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

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

The description is exceptionally concise: two sentences deliver the core purpose and a key constraint. Every word earns its place, and the structure front-loads the critical 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?

Given no parameters and no output schema, the description provides sufficient context for understanding the tool's purpose and the significance of the evidence group. Some detail about the return structure would improve completeness, but it is not 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?

The tool has zero parameters, so the description logically addresses nothing about parameters. According to guidelines, this warrants a baseline score of 4, as no additional parameter information is 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?

The description clearly states the tool reads runtime provider contracts and groups them into five categories (evidence, preview, planned, first-party, derived). It uses a specific verb 'read' and resource 'provider contracts', and distinguishes from sibling tools like get_data_sources by focusing on contract groupings.

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

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

The description implies usage by noting that only the evidence group supports factual claims, hinting at when to use each group. However, it does not explicitly guide when to use this tool versus siblings or state prerequisites, leaving some ambiguity.

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

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

With no annotations, the description carries full responsibility for behavioral disclosure. It correctly indicates read-only behavior ('Read') and lists return contents, but lacks details on potential side effects, permissions, or rate limits. The absence of parameters limits risk, but more explicit safety guarantees would improve 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 sentence with a colon-separated list, making it compact but somewhat dense. It front-loads the key verb and resource. Minor improvement would be to break into bullet points for readability.

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 zero parameters and no output schema, the description adequately covers the tool's purpose and scope by listing the data categories. It is sufficient for an AI to understand what the tool returns, though it could mention if any default or filtering exists.

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

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

There are no parameters, so the schema coverage is trivially 100%. The description does not need to add parameter information, and the baseline score of 4 applies.

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

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

The description clearly specifies the verb 'Read' and the resource 'governed upstream source registry', and enumerates several specific data types included (e.g., publisher datasets, stable source ids, licence decisions). This distinctively differentiates it from sibling tools like get_data_providers or get_source_provenance.

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

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

The description does not provide any context on when to use this tool versus alternative siblings, nor does it specify any prerequisites or exclusions. It only states what the tool does without guiding 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?

With no annotations, the description carries full burden. It states what is included in the return but omits side effects, permissions, rate limits, and failure behavior (e.g., if id doesn't exist). This is adequate but incomplete.

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 of 17 words, front-loaded with the action and resource, and no wasted words. Every part is informative.

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 one required parameter, no output schema, and no annotations, the description covers the purpose and return contents. Could be more complete by mentioning whether the response is singular or an array, but overall sufficient.

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

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

Schema coverage is 100%, and the schema already describes the id parameter. The description adds no extra semantic meaning beyond the schema. Baseline score of 3 is appropriate.

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

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

The description uses a specific verb ('Get') and resource ('governed economic signal'), and lists return contents (provenance, lifecycle state, mappings, uncertainty boundaries). It clearly distinguishes from sibling tools like list_economic_signals (which lists rather than gets one).

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: call with an id from list_economic_signals. However, it provides no explicit guidance on when to use this tool vs alternatives (e.g., get_emerging_signals, get_source_provenance), nor 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 that community figures are structured estimates, not official measurements, which is important behavioral context. It also explains the reconciliation to provincial totals, but does not explicitly state that the tool is read-only or safe, though this is implied by the tool name.

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 paragraph of three sentences, front-loaded with the main purpose. Every sentence adds value, and there is no redundancy.

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

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

Given zero parameters, no output schema, and no annotations, the description thoroughly covers what the tool does and what it returns, including the methodology and data source caveat. It is fully sufficient for an agent to understand and invoke the tool correctly.

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

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

The tool has no parameters, so the description cannot add meaning beyond the schema. However, it provides context about what the tool returns, which indirectly relates to its use with no 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 provides modeled community GDP for Saskatchewan, with specific details on data sources and methodology. It distinguishes itself from sibling tools like get_community_economy by offering a province-wide overview.

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

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

The description does not provide any guidance on when to use this tool versus alternatives such as get_community_economy or compare_outcomes. No usage context or exclusions 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?

No annotations are provided, so the description carries the full burden of behavioral disclosure. The description discloses that this is an alias that delegates to list_economic_signals, which is transparent about delegation behavior. However, it doesn't describe the actual behavioral traits of the underlying operation—no return format, pagination behavior, read/write safety, or data scope. For an unannotated tool, this is a meaningful gap.

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

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

A single-sentence description with zero waste. It's under-specified given the 0% schema coverage and no annotations, but as a text it is tightly written and immediately front-loads the key fact (it's an alias). The brevity is appropriate for the limited substance being communicated.

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

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

This is a 2-parameter tool with no annotations, no output schema, and 0% schema description coverage. The description only communicates 'alias of X' and leaves the agent to infer everything else about what economic signals are, what the pagination returns, and what the canonical tool does. For a tool acting as a thin alias, this is borderline acceptable, but the complete absence of behavioral or return information makes it incomplete for an unannotated tool.

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

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

Schema description coverage is 0%, so the description must compensate for explaining the limit and offset parameters, but it does not mention them at all. However, limit/offset are common, self-explanatory pagination parameters, and with 0 required parameters and a simple numeric type, the schema itself is fairly readable. The description adds zero value beyond the schema, but the parameters are simple enough that the baseline isn't heavily penalized beyond a 3.

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

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

The description states it is a 'Backward-compatible alias for list_economic_signals.' It identifies that this is a pointer to another tool rather than its own function, and mentions the sibling tool by name. However, it doesn't clarify what economic signals actually are, what the tool returns, or what distinguishing purpose this alias serves beyond being a compatibility shim. The word 'alias' implies low intrinsic value, making the purpose only partially 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?

By explicitly naming list_economic_signals as the canonical tool, the description implicitly tells the agent to use that tool when possible and only use this alias for backward compatibility. This provides meaningful usage context (prefer the canonical tool, use this for legacy callers). It doesn't explicitly state when NOT to use it, but the alias framing conveys the appropriate guidance.

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

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

No annotations are provided, so the description must carry the burden. It uses 'Retrieve' which implies a read operation, and lists return contents, but does not explicitly state read-only behavior, error/not-found handling, or authorization requirements. The phrase 'permitted interpretation' hints at governance but is vague.

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

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

The description is a single sentence, front-loaded with the verb 'Retrieve', and contains no redundant or tangential information. Every part adds meaning.

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?

As a simple getter with no annotations or output schema, the description is adequate but incomplete. It does not mention that id may need resolution via resolve_entities first, nor does it clarify what 'permitted interpretation' means. More guidance on when to use this tool vs siblings would improve completeness.

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

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

The schema already provides a detailed description for id (canonical id, slug, or name from resolve_entities) and a full enum for type. The description adds no parameter information, but the schema coverage is sufficient for these two parameters, so the baseline 3 applies.

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

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

The description uses the specific verb 'Retrieve' and identifies the resource as 'one governed entity record' with enumerated components (evidence, provenance, canonical links, permitted interpretation). It clearly distinguishes this general entity getter from siblings like get_role or get_sector that target specific entity types.

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

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

The description implies this is for fetching a single entity by type and id, but it does not state when to prefer this over resolve_entities or search_entities, nor does it name alternatives or exclusions. The context is clear but under-specified.

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

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

With no annotations, the description carries full burden. It discloses it is a single-call fetch that preserves evidence/provenance, but does not clarify what 'governed context' includes, error handling, or permissions. This is adequate for a read-only tool but not rich.

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

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

The description is a single well-structured sentence that front-loads the core action and then adds necessary detail. Every clause earns its place 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?

The tool supports 22 entity types with no output schema and no annotations. The description does not outline the response shape, how responses differ by type, or what to expect from 'governed context.' This is insufficient for the tool's complexity.

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

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

Schema covers id with a description but type only has enums. The description adds that id accepts canonical id, local slug, or exact name, and lists some resource types. This supplements the schema partially, but does not explain type-id matching or how type affects routing.

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

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

The description clearly states the tool fetches 'governed context for one resolved entity in a single call,' using a specific verb and resource. It distinguishes from siblings like get_entity by emphasizing 'governed context' and preservation of evidence/provenance.

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 implies usage after resolving an entity and mentions routing across resource types, but does not explicitly exclude alternatives or state when not to use. The reference to 'from resolve_entities' gives context, but lacks explicit when-to-use versus alternatives.

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

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

With no annotations, the description carries the full burden of behavioral disclosure. It states a retrieval action but does not mention read-only nature, potential errors, rate limits, or what 'governed' implies operationally. Listing the retrieved attributes is semantic rather than behavioral.

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

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

The description is a single sentence that starts with the verb and omits filler. It efficiently conveys the core purpose, though a slight restructuring could improve readability; still, every word earns its place.

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

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

For a simple one-parameter tool without an output schema, the description lists the expected content areas (lineage, licence boundary, releases, serving status), which gives a reasonable sense of what is returned. However, it omits behaviors like handling an omitted id or empty results. Adequate but with clear gaps.

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

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

The input schema fully describes the single optional parameter 'id' with a cross-reference to get_data_sources and get_data_providers. The tool description reinforces that the id can be a source or provider id, but adds no additional syntax or format details. Since schema coverage is 100%, baseline 3 is appropriate.

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

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

The description uses the specific verb 'Retrieve' and identifies the resource as 'a governed upstream source or runtime provider' along with key attributes (lineage, licence boundary, releases, serving status). This provides a clear sense of the tool's scope and distinguishes it from siblings like get_source_provenance, though the term 'evidence' could be more 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?

No explicit guidance on when to use this tool versus alternatives such as get_source_provenance or get_entity_context. The parameter description hints that ids come from get_data_sources/get_data_providers, but this is not sufficient to establish clear usage context or exclusions.

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

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

With no annotations provided, the description carries the full burden of disclosing behavioral traits. It simply says 'Get', implying a read operation, but does not explicitly confirm it is non-mutating, mention any permissions needed, or describe return behavior. The word 'generates' hints at on-the-fly computation but this is left vague.

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 entire description is a single, front-loaded sentence that states the primary purpose and then lists the specific asset types. There is no wasted verbiage or redundant information.

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

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

For a simple two-parameter retrieval tool with an enum, the description covers the essential information: what it gets and the valid asset identifiers. It lacks details on return format or use cases, but given the tool's simplicity, it is largely complete. Would benefit from a note on when to retrieve these assets.

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 0% description coverage, so the description must compensate. It does mention the two valid assetId enum values in prose, and 'from the business's own record' hints at businessId. However, it does not explain the format or purpose of businessId beyond that. The schema already provides the enum, so the added value is moderate.

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: retrieving an asset generated by OEX from a business's own record, and explicitly names the two possible asset types ('local-business-jsonld' or 'corrected-info-block'). This distinguishes it from sibling get_* tools that retrieve other entity types.

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

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

The description implies usage for these two specific asset types but provides no explicit when-to-use or when-not-to-use guidance versus alternatives. It does not mention any exclusions or scenarios where another tool would be preferable, which is notable given the large set of sibling 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?

No annotations are provided, so the description carries the full burden. It adds useful context about timestamps making the sequence auditable, implying chronological ordering, but it does not explicitly confirm the operation is read-only or disclose any pagination, filtering, or permission requirements.

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 that efficiently conveys the tool's purpose and content without unnecessary words. It is front-loaded and earns its place with specific details about event types and timestamps.

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 annotations and no output schema, the description provides a broad overview of return content (detected, reported, verified, timestamps) but lacks details on how checkId filters the history, whether results are ordered, and any limits or edge cases. This makes it moderately incomplete for an agent to invoke the tool correctly 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 defines two parameters (checkId, businessId) with no descriptions, and the description does not address either parameter. It only vaguely references a 'sandbox business,' which maps to businessId, but checkId is completely unexplained, leaving a significant gap in parameter understanding.

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

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

The description clearly states the tool returns 'the event history for a sandbox business' and details the three types of events (detected, owner reported, recheck verified) with timestamps. This distinguishes it from siblings like get_business_health, which likely return current status rather than history.

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

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

The description implies the tool is for viewing historical audit trails of a business, but it does not explicitly state when to use it instead of alternatives or provide exclusions. No mention of pairing with start_health_action or report_health_action_complete, leaving usage to be inferred.

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

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

With no annotations provided, the description carries the full burden. It discloses the core behavior (returning inventory and reconciliation status), explains the semantics of 'ok=true', and notes that additional materializers may add records. No side effects are mentioned, but it is likely read-only.

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, dense sentence that front-loads the primary action and then provides necessary interpretative context. Every clause adds information; no waste.

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

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

Given the tool's simplicity (no parameters, no output schema), the description covers the key elements: what is returned, the meaning of 'ok', and a potential caveat. It could be slightly more detailed about the exact structure of the inventory, but it is adequate for confident use.

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

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

There are zero parameters, so the schema conveys all necessary input information. The description adds value by explaining the output semantics, which is especially helpful given no output schema exists.

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

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

The description uses a specific verb 'Return' and identifies the resource as 'current database graph inventory' with additional details on reconciliation. It clearly distinguishes this status tool from sibling query tools like query_knowledge_graph.

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

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

The description implies usage by indicating it returns inventory and reconciliation status, but it does not explicitly state when to use it versus alternatives. It offers useful context about the meaning of 'ok' and caveats about materializers, though no exclusions.

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

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

With no annotations, the description must disclose behavior. It mentions 'governed' and the distinction among four data categories, but does not explain permissions, return structure, or any side effects. This is minimal 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 compact sentence, front-loaded with the resource and action. No filler or redundancy.

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

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

Given no output schema and no annotations, the description partially covers what the agent gets by naming the distinct evidence categories. However, 'governed' and the response format are undefined, so it is adequate but not complete.

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

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

The tool has zero parameters, so there is nothing to describe; schema coverage is trivially 100%. The description does not add parameter semantics but 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?

The description clearly states the tool retrieves Saskatchewan labour-demand evidence and specifies the categories it keeps distinct. This differentiates it from sibling tools like get_economic_signal or get_wages by focusing on labour demand with a governance qualifier.

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

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

No explicit when-to-use or alternative tool guidance is provided. The description implies use for labour-demand evidence but does not contrast with sibling tools or state exclusions.

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

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

The description discloses the tool is a read-style reporting tool ('Returns current counts...'). However, it doesn't state whether this is a read-only operation or whether the 'next defensible data action' could trigger mutations or writes. With no annotations provided, the description partially carries the transparency burden but leaves ambiguity about 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?

Single sentence serving both as overview and scope definition. It's front-loaded with the key purpose (evidence availability work queue) followed by the specific data points returned. Compact and dense with information, though slightly long as one 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?

For a no-parameter, no-output-schema reporting tool, the description covers the main scope (all municipalities), the key output dimensions (Tier counts, coverage, model inputs, context status, next action), and the data granularity. It doesn't describe the return format, but with no output schema and a broad listing tool, the description is reasonably complete. Could mention sorting or filtering behavior but this is a minor 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?

There are 0 parameters, so the schema provides no parameter information at all. Schema coverage is 100% only because there are no parameters to cover. The description adds context about what all municipalities are included (17 cities, 149 towns), which effectively documents the implicit scope of the no-parameter call. With 0 params, the baseline is 4 per the rubric, and the description does clarify the full coverage scope.

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 what it does: returns a work queue of evidence availability and confidence-gate status for Saskatchewan municipalities. The verb 'returns' plus specific fields (Tier A-D counts, coverage, model inputs, local-context status, next action) make the purpose concrete. It doesn't explicitly distinguish from siblings like get_community_economy, but the domain (municipality evidence coverage) is distinct enough from the economic/role/job tools.

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

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

The description implies when to use: when assessing evidence readiness or confidence-gating for municipalities/communities. It names the scope explicitly (17 cities, 149 towns) but doesn't give explicit when-not-to-use guidance or name alternative tools for similar needs. Given zero annotations and no other guidance, the usage context is implied rather than explicit.

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

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

No annotations exist, so the description carries full burden. It discloses the output contents (median price, listings, velocity, own-vs-rent cost) and notes that passing municipalityId adds price trend and full ownership model. It does not explicitly state it is read-only or has no side effects, but the data retrieval nature is clear.

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

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

Two sentences, no wasted words. Key information is front-loaded: purpose, data types, and parameter behavior are all present.

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

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

No output schema, but description gives a solid overview of returned fields. It might lack details on time period or data source, but these are plausible retrievable from sibling tools. Adequate for an agent to decide.

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 describes municipalityId with example, and the description adds that passing it yields price trend and full ownership model. This adds meaning beyond the schema's brief description.

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

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

The description clearly states the tool provides housing market data including median price, listings, market velocity, and own-vs-rent cost. It distinguishes from siblings like get_rents by offering a broader set of housing metrics.

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 when to pass municipalityId (to get detailed per-community data) and implies omitting it returns all communities. However, it does not explicitly compare to alternatives like get_rents or get_community_economy.

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

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

With no annotations, the description covers behavioral traits: suppressed cells are null, unsurveyed centres absent, and data is from October survey. It does not mention auth or rate limits but discloses data quirks.

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

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

The description is two sentences, front-loaded with the main purpose and key details. Every sentence adds value with zero redundancy.

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

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

Given no output schema, the description fully explains what is returned (rents, vacancy rates, null handling) and covers edge cases (suppressed, absent centres). Complete for a simple two-parameter tool.

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

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

Schema coverage is 100% with descriptions for both parameters. The description adds context beyond schema by explaining the three usage modes (province, centre, neither) and the meaning of cmhcCode.

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

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

The description clearly states it provides average rents by unit type and vacancy rates for Canadian rental markets, sourced from CMHC/StatCan. It distinguishes from sibling tools like get_real_estate by specifying the data source and scope.

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

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

The description explains when to use province, centre, or neither for national overview. However, it does not explicitly state when not to use this tool or mention alternative tools for filtering.

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

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

No annotations are provided, so the description must cover behavioral traits. It discloses what data is returned (market figures, income by community, etc.), but does not mention if the tool is read-only, any required permissions, or data freshness. The description is adequate but not exhaustive.

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

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

The description is a single, clear sentence that front-loads the core purpose. No unnecessary words or tangential 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 one-parameter getter with no output schema or annotations, the description effectively explains what the tool returns. It is mostly complete, though it could clarify output format or any limitations.

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

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

Schema coverage is 100% with one parameter 'id' described as 'Role id from list_roles.' The description does not add further meaning beyond this, so the baseline score of 3 is appropriate.

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

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

The description explicitly states 'One occupation in full' and lists specific data elements (market figures, entry requirements, etc.), clearly indicating this tool retrieves comprehensive details for a single role. It distinguishes from siblings like list_roles (listing) and compare_roles (comparison).

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 is for retrieving full details of a single occupation, and context from sibling tools (e.g., list_roles for obtaining IDs, compare_roles for comparison) provides implicit guidance. However, no explicit when-to-use or when-not-to-use instructions are given.

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

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

Describes the output (occupations, postings, employers), which conveys read behavior. However, with no annotations, it does not disclose other traits like data freshness, authorization needs, or performance characteristics. 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, front-loaded sentence that packs all key information without waste. Every word earns its place.

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

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

For a simple single-parameter tool with no output schema, the description adequately specifies the return content. Could mention that it returns a single sector object, but current description is sufficient for an agent to understand the scope.

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 of the 'id' parameter references 'list_sectors' for obtaining valid ids, adding useful context beyond the schema. Schema coverage is 100%, but this hint helps agents prepare the input 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?

Description clearly states that the tool retrieves a single sector's occupations, provider-qualified postings by community, and notable employers. It distinguishes itself from sibling tools like 'list_sectors' (which lists all sectors) and 'get_role' (which focuses on a specific 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?

Implies usage when details of a specific sector are needed, but does not explicitly state when to use this over alternatives like 'list_sectors' or 'get_community_economy'. No exclusions or prerequisites 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?

No annotations are provided, so the description carries the full burden. It discloses that the tool resolves IDs and returns lineage, but does not mention read-only nature, required permissions, or potential side effects. For a lookup tool, this is adequate but not thorough.

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 two sentences that convey the core functionality, input options, and special case without any unnecessary words. Every sentence earns its place.

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

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

Given the tool has a single optional parameter and no output schema, the description covers the basics. However, it lacks details on the return format (e.g., structure of lineage) and how it relates to sibling tools like get_data_sources and get_data_providers beyond input IDs. More context would improve completeness.

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

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

The input schema has 100% coverage with a single optional parameter 'id' described. The description adds that omitting id returns the upstream source registry, which goes beyond the schema's description. This clarifies the default behavior, adding significant value.

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

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

The description clearly states the tool resolves either a governed upstream source id or runtime provider id and returns the matching source or categorized provider with lineage. It also mentions a default behavior when id is omitted. However, it does not fully distinguish from siblings like get_data_sources or get_data_providers beyond mentioning them.

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

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

The description hints at usage by referencing 'from get_data_sources or get_data_providers' and notes that omitting id returns the upstream source registry. However, it does not explicitly state when to use this tool versus alternatives, nor does it provide exclusions or prerequisites.

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

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

With no annotations, the description carries the disclosure burden. It does disclose a meaningful behavioral trait: 'Station-level CGC rows are excluded pending commercial redistribution permission.' This is genuinely useful caveat about data completeness. However, it doesn't disclose return format, data freshness, or whether the data is aggregated at provincial vs sub-provincial levels.

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

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

Two sentences, zero waste. The first sentence states the core purpose tersely, and the second provides a critical caveat about data exclusions. Every word earns its place.

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

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

For a zero-parameter tool with no output schema and no annotations, the description is reasonably complete about what data it returns. However, as a data retrieval tool it could disclose more about the granularity (time series? latest year only?), units (CAD?), and the nature of 'excludes station-level CGC rows' implication for interpretation. The exclusion note is good but leaves the reader wondering what CGC means and how complete the remaining data is.

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

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

The tool has 0 parameters, so there are no parameters requiring semantic explanation. Per the rubric, 0 params = baseline 4. The description adds context about data origin (Statistics Canada) and scope (Saskatchewan, NAPCS section) which is helpful.

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 the tool provides Saskatchewan merchandise exports by NAPCS section from Statistics Canada, which is a clear verb+resource+scope. However, it doesn't distinguish itself from siblings like get_economy_overview or get_economic_signal, though the specific export focus is fairly unique among the sibling list.

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 doesn't mention when exports data would be preferred over other economic indicators, nor are any exclusions or alternative tools named. The implied context is general economic data retrieval but nothing explicit.

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

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

No annotations are provided, so the description must carry the burden of behavioral disclosure. It does disclose the nature of the returned data (units, period, source, confidence, comparability qualifications), but omits details such as behavior when no evidence exists, error conditions, or whether authentication/rate limits apply. This is adequate but not rich.

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

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

The description is a single sentence that front-loads the verb and resource, then concisely lists the return components. Every word earns its place; there is no redundancy or filler.

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

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

For a low-complexity tool with two parameters and no output schema, the description covers both the input requirement (occupation and geography) and the output components (units, period, source, confidence, comparability). It lacks differentiation from sibling tools and does not mention edge cases, but given the simplicity, it is reasonably complete.

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

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

The input schema already describes both parameters (noc and province) at 100% coverage. The description's phrase 'for an occupation and geography' loosely maps to these parameters but adds no new semantic detail beyond what the schema provides. The baseline of 3 is appropriate.

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

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

The description uses a specific verb 'Retrieve' and names the resource 'wage evidence', while also listing the key return components (units, period, source, confidence, comparability). However, it does not explicitly differentiate itself from the similarly named sibling tool 'get_wages', which weakens distinction.

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

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

No guidance is given on when to use this tool versus alternatives like 'get_wages' or 'get_evidence'. The description only states that it retrieves wage evidence for an occupation and geography, but lacks context on prerequisites, exclusions, or preferred 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?

With no annotations, the description carries the full burden. It notes data is 'real data' from Statistics Canada and clarifies that wage medians are group-level, adding some transparency. But it omits details on update frequency, authorization needs, or potential rate limits, which would help an agent.

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 paragraph of four sentences, front-loaded with the core purpose. Every sentence adds value with 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 tool has no output schema, so the description should compensate. It covers all parameter usage modes and mentions that results include grouping names, but does not describe the return format or data structure (e.g., table, JSON). Still, for a simple retrieval tool, it is mostly complete.

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

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

Schema coverage is 100%, so baseline is 3. The description adds substantial meaning beyond schema: it explains the effect of passing none, one, or both parameters, and clarifies that wage medians are group-level with published grouping names.

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

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

The description clearly states the tool returns wage and vacancy data from specific Statistics Canada datasets (LFS, JVWS) with dimensions like occupation group and province. It implicitly distinguishes from sibling tools by focusing uniquely on wages and vacancies, which are not covered by other 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 provides explicit guidance on parameter combinations: pass noc for geographies, province for one geography, both for one cell, neither for national overview. It does not, however, mention when not to use this tool or suggest alternatives.

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

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

No annotations are provided, so the description carries the full burden. It discloses that the consent is purpose-scoped, acts on behalf of the sandbox business, and that consent classes are isolated (granting one doesn't widen another). However, it doesn't disclose side effects, reversibility, permissions required, or what happens on success/failure—significant gaps for a mutation-like action.

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

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

The description is three sentences and front-loaded with the core action. The second and third sentences provide valuable context (invitation trigger, class isolation) without unnecessary fluff. Slightly more detail on return behavior could be added, but the text is compact and purposeful.

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

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

For a tool with 2 parameters, no output schema, and no annotations, the description gives enough to understand the basic operation and trigger context. However, it lacks details on what the grant produces (e.g., confirmation, resulting state), potential errors, or prerequisites. The class isolation statement adds useful context but does not fully address the completeness needed for an action tool.

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

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

Schema description coverage is 0%, so the description must compensate. It adds meaning to 'consentClass' by stating classes are separate and purpose-scoped, and to 'businessId' by implying it identifies the sandbox business on whose behalf consent is granted. However, the specific enum values (e.g., 'listing', 'operating_detail') are not explained, leaving the agent to infer their meaning from names alone.

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

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

The description uses a specific verb+resource: 'Grant a purpose-scoped consent on behalf of the sandbox business.' It clearly states the action and scope, and the phrase 'This is what an invitation in the report is asking for' anchors its purpose. It distinguishes itself from all sibling tools, none of which grant consent.

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

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

The description provides clear context for when to use the tool: when an invitation in the report requests a consent grant. It also implies a usage rule by emphasizing 'The classes are separate on purpose: granting one never widens another,' suggesting the agent must consider each consent class independently. However, it does not explicitly name alternatives or exclusions, though no direct alternative tool exists.

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

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

No annotations are provided, so the description carries the full burden of behavioral disclosure. It discloses the nature of results (current/historical evidence, amendments, conflicts, provenance, missing-evidence boundaries) and explicit limitations (no private relationships). While it doesn't cover permissions, rate limits, or data freshness, the description does provide meaningful behavioral context beyond a simple read-only hint.

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

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

The description is three sentences, front-loaded with the core purpose, followed by a concise summary of returns and explicit non-goals. Every sentence earns its place, and the non-goals sentence adds differentiation 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 5 optional parameters, no output schema, and no annotations, the description provides a solid overview of the tool's scope and outputs. It lists the types of evidence returned and what is excluded, which gives sufficient context for an agent to decide whether to invoke it. It could be more detailed about how filters combine or what the response structure looks like, but it covers the essential aspects.

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

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

The input schema provides 100% coverage, with each parameter having a clear description (e.g., 'Exact source-scoped organization id from resolve_entities'). The description adds a high-level grouping of filter dimensions but no additional syntax or format details beyond the schema, so the baseline score of 3 applies.

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

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

The description clearly states a specific verb ('inspect') and resource ('official Saskatchewan CanadaBuys procurement observations') with three explicit filter dimensions (buyer, notice, UNSPSC category). It also differentiates from siblings by listing what it does not do (rank tenders, infer supplier fit, expose private relationships), 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 gives clear context for when to use this tool (inspecting procurement observations with specific filters) and explicitly states exclusions ('does not rank tenders, infer supplier fit, or expose private relationships'). However, it does not name alternative tools for those excluded purposes, so it stops short of full alternative guidance.

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

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

With no annotations provided, the description carries the full burden and does well by revealing that OEX does not invoke a hosted model or hidden reasoning chain, is deterministic, bounded, and synthesizes only from evidence. This adds meaningful behavioral context beyond the schema, though it does not detail return structure or permissions.

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

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

Two sentences, front-loaded with the main workflow and a clarifying limitation. Every phrase earns its place; there is no fluff, repetition, or irrelevant 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 5-parameter tool with no output schema, the description covers the high-level orchestration, return type (citation-ready evidence bundle), and a key limitation. It could be more complete by specifying the shape of the plan or guidance on depth/confidence, but it is sufficient for correct invocation.

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

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

Schema coverage is 80%, so the baseline is 3. The description adds context for 'governed entities' and 'bounded' calls, which loosely map to the entities and maxEvidenceCalls parameters, but it does not provide syntax or deeper semantics beyond what the schema already documents.

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

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

The description uses specific action verbs ('Turn...resolve...execute...return') and clearly states the resource: a natural-language economic question processed through OEX graph/data primitives. It differentiates from sibling get/query tools by emphasizing an inspectable deterministic plan and a citation-ready evidence bundle.

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?

Use is implied for natural-language economic questions, but there are no explicit when-to-use or when-not-to-use instructions. The description does not mention alternatives like resolve_entities, query_knowledge_graph, or get_evidence, nor does it specify exclusions.

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

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

With no annotations provided, the description carries the burden for behavioral disclosure. It discloses that rows preserve 'lifecycle state and uncertainty' and that notices don't prove outcomes - valuable semantic caveats. However, it doesn't disclose pagination behavior, rate limits, or what happens with large result sets; 'governed' hints at curation but is vague.

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

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

Two sentences, zero filler. The first sentence states the core function, the second delivers meaningful interpretive guidance. Every word earns its place.

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

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

This is a simple paginated list tool with no output schema and fully-documented params. The description covers purpose, scope, and important data-semantics caveats. Minor gap: 'governed' is undefined and could benefit from clarification about what governance means operationally, but for a list tool the coverage is largely sufficient.

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

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

Schema coverage is 100%, with both limit and offset already described ('Page size', 'Zero-based page offset'). The description adds no parameter-level detail beyond what the schema documents. Baseline 3 is appropriate when the schema fully covers both 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?

Clear verb+resource ('List...economic signals') with a jurisdictional scope ('Saskatchewan') and source qualifier ('official structured sources'). Distinguishes itself from siblings like get_economic_signal (singular fetch) by being the plural listing operation, though it doesn't explicitly name an alternative.

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 vs alternatives. The description does add an interpretive caveat about notices not proving outcomes, which implies caution around data semantics, but there's no when-to-use or when-not-to-use guidance relative to sibling tools like get_emerging_signals or get_economic_signal.

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

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

With no annotations, the description carries full behavioral disclosure. It reveals the tool returns all 516 unit groups with specific fields (bilingual titles, TEER tiers, platform coverage flags). It doesn't mention sorting, pagination, or cost implications, but for a static classification list, this is sufficient 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 consists of two sentences: the first defines what the tool provides, the second gives a direct use case. It is concise, front-loaded with the key information, and contains no unnecessary words.

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

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

Given the tool has no parameters and no output schema, the description is fairly complete. It explains the content (516 unit groups, fields) and purpose (mapping occupations to codes). It could mention that it's the entire classification (no filtering), but it's still informative enough for an agent.

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

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

There are no parameters in the input schema, so the description doesn't need to elaborate on parameters. The baseline score for 0 parameters is 4. The description adds no param info, but that is appropriate.

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

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

The description clearly states it provides the complete NOC 2021 occupational classification with all 516 unit groups, bilingual titles, TEER tiers, and coverage flags. It distinguishes itself from sibling tools like 'get_role' (single role) or 'list_roles' (maybe a different list) by specifying it's the full classification.

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

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

The description explicitly says 'Use to map any Canadian occupation to its code,' which is a clear use case. It doesn't discuss when not to use it or alternatives, but the sibling tools context and the nature of the tool make the intended usage 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?

With no annotations, the description must disclose behavioral traits. It lists output fields and non-destructive intent (listing), but lacks details on data freshness, pagination, or any limits. It does not contradict annotations since none 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?

Two sentences, front-loaded with the tool's purpose and key output fields. Every word earns its place; no redundancy.

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

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

Given no output schema, the description adequately explains return values by listing fields. For a simple list tool with no parameters, it is fairly complete. It could mention that it returns all roles, but this is implied.

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

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

There are no parameters, and schema coverage is trivially 100%. The description adds value by naming the output fields (id, title, NOC code, etc.), providing meaning beyond the empty input 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 identifies the tool as listing roles from the Saskatchewan occupation catalogue, specifies the fields (id, title, NOC code, sector, hourly wage, demand score), and states its use as a starting point for finding role ids. It distinguishes from siblings like 'get_role' which retrieves details for a single role.

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

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

The description explicitly says 'Start here to find role ids,' indicating it is the entry point for role information. It implies usage before more specific tools like 'get_role' or 'get_sector', but does not explicitly state when not to use it or list alternatives beyond context.

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

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

With no annotations, the description carries the burden of behavioral disclosure. 'List' implies a read-only operation, and the tool has zero parameters, so the risk is low. However, the description does not disclose return value shape (e.g., identifiers, names) or any ordering/pagination behavior, which would be useful context.

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

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

The description is a single, concise sentence that earns its place. It immediately states the action and the purpose without any filler, making it easy for an agent to parse quickly.

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

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

For a zero-parameter, read-only list tool, the description provides sufficient context: it tells what is listed and why. The only gap is the lack of an output schema or explanation of what fields are returned, but the purpose 'resume working on one' implies the returned items are identifiable enough for continued work.

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 is empty (0 parameters), so parameter semantics are not a concern. Per the baseline for zero-parameter tools, the description need not explain parameters. It correctly focuses on the tool's purpose rather than inventing parameter details.

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

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

The description uses a specific verb ('List') and resource ('sandbox businesses') and states the intended purpose ('so you can resume working on one'). It clearly distinguishes itself from sibling tools like create_sandbox_business by focusing on existing sandbox businesses rather than creation or general business search.

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 'so you can resume working on one' provides a clear contextual trigger for when to use this tool. It does not explicitly mention alternatives, but the 'sandbox businesses' qualifier implicitly separates it from broad business search tools like search_businesses, so the usage context is reasonably 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?

With no annotations provided, the description carries the transparency burden. It discloses that the tool aggregates provider-qualified hiring counts, excludes candidate profiles, and requires reading meta.evidence before interpreting counts. This adds meaningful behavioral context beyond the bare listing operation, though it does not detail auth, rate limits, or 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?

Three concise sentences, each adding specific value: what is provided, what is excluded, and an essential interpretive warning. No filler or redundancy.

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

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

For a parameterless read-only listing tool without an output schema, the description covers the main content, exclusions, and a critical data-quality caveat. It is reasonably complete, though it could be slightly stronger by specifying the output structure or how sectors are organized.

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

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

The tool has zero parameters, so the description need not explain parameter semantics. The baseline of 4 is appropriate since there is nothing to clarify.

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 tool as providing sector rollups with specific data elements (hiring-record counts, median wage, occupation demand), distinguishing it from sector-specific tools like get_sector and other rollup tools. The exclusion of candidate profiles further clarifies scope.

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

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

The description provides clear context: use for sector-level rollups with hiring, wage, and demand data. It also notes an exclusion (candidate profiles are not included) and a prerequisite caution (read meta.evidence), though it does not explicitly name alternative tools or when-not-to-use conditions.

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

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

With no annotations, the description carries the burden and adds important behavioral traits: it queries a materialized graph, returns typed facts/relationships, and explicitly states that missing facts or edges mean 'unknown, never zero or false.' It does not mention rate limits or auth, but the read-only query semantics and unknown-value rule are valuable.

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?

Four sentences, each earning its place: purpose, operation, use case, and a key semantic caveat. Information is front-loaded and no filler is present.

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

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

For a 13-parameter tool with no output schema or annotations, the description provides a helpful orientation but not complete context. It lacks explicit guidance on response structure, pagination/limits behavior, and when to prefer sibling tools like traverse_relationships or get_entity.

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 85%, so the schema already documents most parameters. The description adds the conceptual linking of entity/geography to the returned facts and relationships, but it does not enrich individual parameter semantics beyond what the schema provides.

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

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

The description uses a specific verb ('Query') and identifies the resource ('materialized semantic graph'), then details the operation: resolve an entity name/code and optional municipality geography to return typed facts and relationships. It also distinguishes itself from sibling tools by emphasizing graph queries without downloading datasets and without encoding classifications in metric names.

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

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

It provides clear usage context: this tool is for municipality-by-NAICS GDP and business queries and for querying the graph instead of downloading whole datasets. It does not explicitly name alternatives or state when not to use it, so it misses the full exclusion guidance.

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

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

No annotations are provided, so the description carries full burden. It does not disclose how discretionary income is calculated, what data sources are used, or any limitations. The description is too terse for a tool with no 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, front-loaded sentence that immediately communicates the tool's action and scope. No wasted words; every word is necessary.

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

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

The description is adequate for the tool's purpose but lacks detail about the output format or the derivation of discretionary income. With no output schema, the description could be more informative to cover expected 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 100% and parameters have descriptions. The description adds value by clarifying that exactly one of 'occupation' or 'wage' should be provided, a constraint not enforced in the schema. This enhances understanding beyond the schema.

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

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

The description clearly states the tool ranks Saskatchewan communities by monthly discretionary income, specifying the constraint of exactly one role or explicit hourly wage. This distinguishes it from sibling tools like get_community_economy, which likely provide data without ranking.

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: for ranking communities based on a single role or wage. It does not explicitly mention alternatives or when not to use, but the constraint 'exactly one role or explicit hourly wage' provides clear usage context.

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

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

With no annotations, the description carries the full burden. It discloses two important behaviors: rate-limiting and the 'unable-to-verify' error handling. It also mentions website inspection. This goes beyond a simple 'recheck' and helps an agent anticipate outcomes, though it stops short of describing the full return format or non-error 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 two succinct sentences. The first sentence front-loads the primary purpose, and the second packs two distinct behavioral notes (website inspection and rate-limited/error reporting) without redundancy. Every word earns its place.

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

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

For a tool with no output schema and a two-parameter schema, the description covers the most critical operational detail (the unusual 'unable-to-verify' outcome) and the contextual trigger ('after fixing something'). It does not explain what a successful recheck returns, but given the action-oriented nature and the clarity of the behavior, it is sufficiently complete.

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

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

Schema description coverage is 50% (only checkId is documented in the schema). The description does not add any parameter-specific semantics; it only implies the business context via the phrase 'a business.' This is adequate but not compensatory for the undocumented businessId since the agent can infer its meaning from the tool name and general context.

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

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

The description clearly identifies the tool as a re-check action ('Ask OEX to look again') specifically for after a fix, distinguishing it from the initial check (check_business_health) and retrieval (get_business_health). It also states the scope (inspects website if supplied), making the purpose unambiguous.

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

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

The description explicitly states the intended use case: after fixing something. This implies a temporal relationship to prior fixes and suggests it should not be used for initial checks. However, it does not explicitly name alternatives or exclusions, so it misses the highest bar.

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

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

No annotations are provided, so the description carries the full burden. It discloses the critical behavior that this only records a claim and does not mark anything as resolved until a recheck passes, which is non-obvious and adds real value. However, it does not mention idempotency, prerequisites, or what happens to the underlying health action record.

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

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

The description is two sentences, front-loaded with the primary action, and contains no filler or redundant content. Every clause earns its place by adding meaning.

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 2-parameter action with no output schema, the description covers the core purpose and a crucial caveat. However, it does not explain the resulting state change, any prerequisites, or the explicit next step of invoking a recheck tool, leaving the overall workflow partially underspecified.

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 0% description coverage, so the description should compensate. It loosely implies checkId is the finding and businessId identifies the owner's business, but it never explicitly explains either parameter, their format, or how they relate to each other. This leaves considerable 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?

The description clearly states the action: 'Record that the owner says a finding is fixed' with a specific verb and resource. It also distinguishes this from verification tools by noting that this is the owner's claim, not OEX's, which separates it from sibling tools like recheck_business_health.

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 it: when the owner claims a fix, not when verification is needed. The phrase 'nothing renders as resolved until a recheck runs' signals the alternative workflow, but it does not explicitly name recheck_business_health or state when not to use this tool.

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

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

With no annotations, the description carries the full burden. It discloses that results include the follow-up tool and arguments, which is useful behavioral context. However, it does not explicitly state that this is a read-only operation or mention side effects, permissions, or failure behavior, leaving some ambiguity.

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

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

Two sentences, no filler. The first sentence states purpose immediately; the second provides usage timing and output hint. Every word earns its place.

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

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

The description covers purpose, when to use, and the key output (follow-up tool and arguments). It lacks details about no-match behavior or how to handle multiple results, but given the schema covers parameters and no output schema exists, it is reasonably complete for a resolution tool.

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

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

Schema description coverage is 100%, so parameters are already well-documented. The description adds a few examples (NOC code, SGC code, program, sector) that slightly expand on the schema's 'official identifier' phrase, but this is marginal and does not significantly enhance understanding beyond the schema.

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

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

The description clearly states the tool resolves a user-supplied identifier (name, slug, NOC/SGC code, etc.) to a canonical OEX identity. It uses a specific verb ('resolve') and resource, and uniquely positions itself as the pre-join disambiguation step, distinguishing it from siblings like search_entities or get_entity.

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

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

The description explicitly says 'Call this before joining datasets when the identifier is uncertain,' providing a clear use case and timing. However, it does not name alternatives or give when-not-to-use conditions, so it falls short of a 5.

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

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

With no annotations, the description must carry the full burden of behavioral disclosure. It mentions returning ranked candidates when ambiguous, which is useful, but it does not disclose behavior for no-match cases, permissions, or rate limits, leaving gaps.

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

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

The description is two concise sentences with no filler, front-loaded with the verb 'Resolve' and immediately conveying the primary action and key behavior.

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

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

With no output schema, the description should clarify return structure more thoroughly. It mentions ranked candidates but not fields, error handling, or how the 'correct next tool' is determined, leaving the tool incomplete for an entity-resolution tool with a broad type enum.

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

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

The input schema already describes all parameters (100% coverage), so the description adds little beyond what the schema provides. It references 'user language' but the schema already enumerates query types as 'Name, alternate title, slug, or official identifier,' so no additional semantic value.

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

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

The description clearly states the tool resolves user language or official codes to a canonical OEX identity and the correct next tool, using a specific verb and resource. This distinguishes it from siblings like search_entities and get_entity, making its purpose unambiguous.

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

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

The description implies usage for ambiguous or natural-language inputs requiring canonicalization, but does not explicitly contrast with siblings like resolve_entities or search_entities, leaving some guidance missing. It provides clear context but no exclusions or alternatives.

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

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

With no annotations, the description carries the burden. It discloses that the tool only returns snapshots and does not infer certain attributes, which is useful context. However, it does not mention return format, pagination behavior, or any other operational traits beyond what the schema already shows.

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

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

The description is a single, front-loaded sentence that immediately states the action and resource. It is concise with no filler, and the 'without inferring' clause adds valuable context without wordiness.

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

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

The description covers the data domain and a key limitation, and the schema explains parameters. However, it does not specify the output structure (no output schema) and does not clarify how this tool differs from the sibling search_licensed_businesses, leaving some contextual gaps.

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

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

Schema description coverage is 100%, so the schema fully documents all parameters. The description adds no parameter-specific meaning beyond implying municipality context, so the baseline of 3 is appropriate.

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

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

The description clearly states it searches 'governed municipal licensed-business snapshots', which is a specific verb+resource. The additional 'without inferring operating health, employment, ownership, or hiring' clause defines scope, but it does not explicitly distinguish itself from the similarly-named sibling search_licensed_businesses.

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 'without inferring' phrase provides a clear when-not: if the user needs inferences about operating health, employment, ownership, or hiring, this tool is not appropriate. However, it does not name alternative tools that would provide those inferences, so it falls short of full guidance.

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

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

With no annotations, the description carries the burden of behavioral disclosure. It adds a key caveat that preview providers return modelled activity scenarios rather than business claims, and clarifies the hiring flag is 'observed'. However, it does not mention other behavioral aspects like rate limits, pagination, or read-only assurances, leaving room for more 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 two concise sentences with no filler. It efficiently conveys the tool's scope and adds a critical data-quality caveat, earning a top score for conciseness and front-loading of key information.

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

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

Given 5 optional parameters and no output schema, the description covers the main search dimensions and the preview-provider caveat. It does not describe the return format or pagination, but for a search tool, the core purpose and caveat are sufficiently communicated, making it fairly 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 100%, so baseline is 3. The description loosely maps to schema parameters (name, municipality, sector group, hiring flag) but does not add details beyond the schema's own parameter descriptions. No extra semantic value is provided.

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 a public business directory by name, municipality, sector group, and observed hiring flag, using a specific verb and resource. However, it does not explicitly differentiate this from siblings like search_businesses or search_licensed_businesses, so it lacks direct sibling differentiation.

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

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

No guidance is provided about when to use this tool versus alternatives. The description lists search criteria but does not mention exclusions, prerequisites, or how this compares to other search-related sibling tools such as search_businesses or search_hiring_activity.

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

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

With no annotations provided, the description carries full behavioral disclosure burden. It reveals matching criteria (names, aliases, slugs, official identifiers) but omits any details about matching behavior (fuzzy vs exact), ordering, pagination, or that it is a read-only operation. 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, front-loaded sentence that efficiently conveys the core purpose. It is not verbose, though it lacks detail that could make it more useful. It earns its place but could be enriched without harming conciseness.

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

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

Given the lack of an output schema and the tool's complexity (multiple entity types, search behavior), the description is incomplete. It does not explain what the response looks like, how results are returned or limited, or how the type constraint works in practice. Significant context is missing.

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

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

The input schema already documents all three parameters with descriptions covering 100% of them. The description adds minimal extra meaning by using 'aliases' instead of the schema's 'alternate title' and by referencing 'OEX entity classes' broadly, but the schema handles parameter semantics well.

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 a search tool for OEX entity classes using names, aliases, slugs, and official identifiers. It distinguishes itself from specialized siblings like search_businesses and search_employers by implying a broader scope, though it does not explicitly differentiate itself.

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

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

No explicit guidance is provided on when to use this tool versus alternatives. It does not mention that specialized tools exist for specific entity types or whether this should be used for broad searches only. The description implies usage but does not offer exclusions or alternatives.

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

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

With no annotations, the description carries the full burden. It discloses key behaviors: rows are observations, not actionable job postings; ordering is newest first; and specific fields (observationDate, lastVerifiedAt, provenance, meta.evidence.truthState, synthetic) must be checked for validity. This adds significant transparency beyond the schema.

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

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

The description is dense and informative, with the core purpose front-loaded. The second sentence about recordPurpose is slightly redundant and jargony, but every sentence contributes essential caveats. It is appropriately sized for a tool with this complexity.

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

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

Given the lack of output schema and annotations, the description provides a solid behavioral foundation: what data is returned, its nature (evidence observations), and validation steps. It does not enumerate return fields beyond the mentioned ones, but the caveats cover the most critical context for correct use.

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

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

Schema description coverage is 100%, so the baseline is 3. The description adds minimal parameter-specific meaning beyond the schema, only noting that filtering by occupation, sector and geography is possible. It does not explain syntax or format details for any parameter, relying on the schema descriptions.

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

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

The description clearly states the tool returns 'Source-attributed hiring-activity evidence, newest first and filterable by occupation, sector and geography.' It distinguishes itself from sibling tools by explicitly noting that rows are 'observations with isActionable=false, not jobs offered for application through OEX,' which sets it apart from job search tools like search_employers.

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 context on when to use this tool (for hiring-activity evidence) and an explicit exclusion ('not jobs offered for application through OEX'). It also advises checking specific fields before using data as current evidence, which is useful guidance, though it does not name alternative tools.

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

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

With no annotations, the description carries the full burden and does so exceptionally. It discloses the data's nature as a snapshot, each row being a licence held on a reference date, and explicitly states what it is not: 'not a legal-entity register, not current beyond that date, incomplete for excluded licence categories, and not evidence of ownership, employment, size or operating health'. It also notes that home-based licences carry no address, which is a key behavioral trait.

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 dense but every sentence earns its place. It front-loads the core purpose, immediately specifies an exclusion and alternative, then adds critical caveats in a structured manner. Despite its length, there is no padding or redundancy.

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

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

Given the complexity of the tool and lack of annotations or output schema, the description provides substantial context: the scope, limitations, and data freshness. It could go further by describing the return structure (e.g., what fields are present), but the cautionary notes about addresses and licence attributes partially cover output expectations. Overall, it is quite complete for a 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?

Schema description coverage is 100%, so all parameters are individually documented in the schema. The description adds no additional parameter-specific details beyond what the schema already provides, such as the meaning of 'q' or 'subsector'. It stays at the baseline where the schema does the heavy lifting.

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 with a specific verb and resource: 'Named businesses holding a municipal licence in one community'. It also distinguishes itself from siblings by explicitly noting 'NOT who is hiring — use search_employers for that', making its scope 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 explicit usage context, stating it 'Answers who exists and in which industry' and explicitly excludes hiring-related queries, directing users to search_employers. It does not cover all possible alternatives (e.g., for cross-community comparisons), but the guidance is clear and sufficient for the primary use case.

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

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

With no annotations provided, the description carries the full burden of behavioral disclosure. It does well by explaining that supplying a domain 'permits inspection' and explicitly stating it does not assert ownership or control, and 'will not publish the domain as the business's own on this basis alone.' This adds valuable context beyond what annotations would provide.

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

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

Two sentences, front-loaded with the action, and no unnecessary words. The structure is efficient and the purpose is immediately clear.

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 2-parameter setter with no output schema and no annotations, the description is adequately complete. It explains the purpose, the key semantic caveat, and the non-side-effect. It does not mention operational details like overwriting existing domains or return behavior, but these are not critical for a tool of this simplicity.

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

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

Schema description coverage is 0%, so the description must compensate. It adds meaningful semantics for 'domain' by framing it as the business's website and clarifying the non-ownership nuance, but it leaves 'businessId' completely undefined. The description offers partial compensation but not full.

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 with a specific verb ('Tell OEX') and resource ('the business's website'). It distinguishes itself from sibling tools by clarifying that the domain is for inspection, not ownership assertion, which is a key differentiator.

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 implies the use case (to enable inspection) but does not explicitly state when to use this tool over alternatives like update_business_record, nor does it provide exclusions or preconditions. The caveat about ownership is a semantic nuance rather than usage 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?

With no annotations provided, the description carries the burden of disclosing behavior. It explicitly states a side effect ('Moves the finding's action state') and explains why that matters ('makes its history readable later'). However, it does not disclose prerequisites, idempotency, or potential errors, leaving some gaps for a mutation tool.