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 reveals a dependency on prior steps in the flow, but it does not state whether the operation is read-only, has side effects, or what the response contains. This leaves key behavioral traits unaddressed.

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

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

The description is one short sentence plus a compact flow arrow, with no filler or redundant content. The purpose is front-loaded, though the flow could be more self-explanatory. Structurally it is efficient.

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

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

For a two-parameter tool with a nested free-form args object and no output schema, this description is insufficient. It omits the meaning of the parameters, the expected args structure, and the return value, and the flow hints at prerequisites without explaining them.

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

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

The schema has 0% description coverage, and the description does not mention formula_id or args at all. Neither the schema nor the description explains what values args should take or how formula_id is to be used, leaving the agent without semantic guidance.

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 'Execute a calculator' uses a specific verb and resource, and the flow 'search_calculator → get_calculator → calculate' places it as the final step, distinguishing it from sibling tools. However, it does not clarify what a calculator is or what 'execute' entails, so it is not as precise as it could be.

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 flow 'search_calculator → get_calculator → calculate' explicitly orders the steps and tells the agent to use calculate after retrieving a calculator. It provides clear context for when to call this tool, though it does not state exclusions or alternatives for other types of calculations.

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?

There are no annotations, so the description carries the burden of explaining behavior. It does disclose what the tool returns (columns, purpose, signature columns) and implies a read-only operation through the verb 'Describe.' However, it does not explicitly address side effects, permissions, or error behavior, though these are less critical for a describe operation.

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

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

The description is two short sentences with no filler. The main purpose and output contents are front-loaded, and the usage guidance is appended in a separate concise 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 simple one-parameter describe tool, the description covers both the returned content (columns, purpose, signature columns) and the recommended invocation context (before run_select). No output schema exists, but the description sufficiently communicates what the agent should expect, though it could clarify what 'signature columns' means or how to obtain valid table names.

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

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

With only one parameter named 'table' and no schema description coverage, the description's phrase 'Describe a table' adds some semantic confirmation that the parameter identifies the target table. It does not specify where valid table names come from or the expected format, but the single self-evident string parameter reduces the risk of confusion.

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

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

The description clearly states a specific action ('Describe') and a concrete resource ('a table'), and enumerates the key output dimensions: columns, purpose, and signature columns. It also frames the tool as a prerequisite step by saying 'Call before run_select', which differentiates it from the run_select 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 gives an explicit usage instruction: 'Call before run_select.' This provides clear context for when to use the tool, but it does not name alternatives or describe scenarios where this tool should not be used, 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, the description carries the burden of disclosing behavior. The verb 'Get' implies a read operation, and the follow-up directive is useful context, but the description does not explicitly state read-only behavior, error cases, or what happens for an invalid formula_id. It 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?

Two short sentences with no wasted words. The first sentence states the tool's output, and the second gives the invocation context. Information is front-loaded and 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?

For a simple single-parameter retrieval tool, the description covers what is returned (inputs, gotchas, related calculators) and when to call it. It lacks explicit read-only and error-behavior statements, but the low complexity and clear output list make it 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?

The schema provides only the parameter name 'formula_id' with 0% description coverage. The description compensates by tying the parameter to the prior search_calculator call, giving the agent a clear source for the value. It does not define format or constraints, but for a single self-descriptive parameter this is sufficient.

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 ('formula_id') and names the delivered content: inputs, gotchas, and related calculators. It is clear enough to distinguish this from search_calculator, but it does not explicitly contrast itself with other sibling tools in the purpose statement 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?

'Call after search_calculator' provides explicit sequencing context, telling the agent when this tool should be invoked. It stops short of a full 5 because it does not state when not to use it or mention alternative tools besides the implied search_calculator.

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. 'Read' makes the operation non-destructive, and 'full text' clarifies the return content. It does not cover error behavior or access restrictions, but for a simple get-by-id tool the core behavior is disclosed.

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 conveys the action, resource, and parameter without wasted words. It is appropriately concise for a simple retrieval tool.

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

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

The description covers the key invocation detail (doc_id) and the return substance ('full text'). It is missing guidance on where doc_id comes from and behavior when the document is not found, so the agent must infer some context from siblings or the environment.

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 is only one parameter, and the description ties it explicitly to the document being fetched, so doc_id's role is unambiguous. However, it adds little beyond the schema's property name and does not specify the expected format or source of valid doc_id values.

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

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

The description uses a specific verb ('Read') and resource ('KB document'), and explicitly identifies the access mechanism ('by doc_id'). It clearly communicates what the tool does, though it does not explicitly differentiate from sibling search 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?

Usage is implied: use this tool when you need the full text of a specific knowledge-base document and have its doc_id. However, it does not explicitly state when to prefer a search sibling or how a valid doc_id should be obtained.

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 behavioral disclosure on its own. It indicates a read-style 'Get' operation and that the result is a full spec row, which is useful, but it does not address return shape, missing-model behavior, or any access constraints.

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 definition is a single front-loaded sentence with no filler; every word contributes. It is appropriately short for a one-parameter getter.

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 getter, the one-liner is close to sufficient, but the absent output schema and lack of behavior/error details leave some ambiguity about what 'full spec' contains. It also lacks routing guidance to distinguish it from lookup_model and search_products.

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

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

Schema coverage is 0% and the only parameter, model_name, is documented only by its title. The description adds the context that the parameter refers to a 'lens model', but provides no format, exact-name requirements, or examples.

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

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

The description states a clear action ('Get') and target ('full spec row(s) for a lens model'), making it understandable as a retrieval operation for lens-model products. It does not explicitly contrast itself with siblings like lookup_model or search_products, so it stops short of full 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 when-to-use guidance or alternatives are provided; the description only states what the tool does. An agent must infer that get_product is for exact model-name spec retrieval and that search_products or lookup_model should be used otherwise.

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 present, so the description carries the full burden. It conveys a read-only get operation and the returned data, but does not describe edge cases (invalid/missing table_id), permissions, or potential failure modes. The behavior is nonetheless simple and predictable.

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

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

Two short sentences, with the operation and return fields front-loaded in the first sentence and the workflow directive in the second. 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 one-parameter getter without an output schema, the description covers the operation, the return contents, and the invocation timing. It does not address error behavior or distinguish from the lookup sibling, but this is a minor gap for such a simple tool.

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

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

The schema only lists 'table_id' with no description, leaving 0% schema coverage. The description refers to 'a lookup table' and instructs calling after search_lookups, which implies table_id comes from those search results, but it never explicitly defines the parameter's source or format. This partially compensates for the missing schema detail.

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

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

Description uses the verb 'Get' with a specific resource ('a lookup table') and lists the exact return fields ('purpose, keys, notes'). This clearly differentiates it from siblings like search_lookups, which searches, or lookup, which likely performs a lookup against the table.

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 explicit instruction 'Call after search_lookups' provides a clear workflow context, telling the agent this tool should be used subsequent to a lookup search. It does not mention alternatives or exclusions, but the sequencing guidance is unambiguous.

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 behavioral burden. It communicates that this is a knowledge-retrieval tool returning documentation-style information, which implies a non-mutating operation. It does not disclose output format, potential errors, or naming requirements, but for a read-oriented knowledge lookup the core behavior is reasonably conveyed.

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?

One sentence with a colon-delimited list of contents. No filler, no repetition of the schema, and the most important element (what knowledge is returned) is front-loaded. Every phrase 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, the description gives a reasonable outline of the returned content. However, with no annotations, no output schema, and no mention of table-name provenance or relationship to describe_table, there are noticeable gaps that could leave an agent uncertain about exact invocation behavior or alternatives.

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

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

Schema description coverage is 0%, so the description must compensate. It mentions 'a table' as the subject, aligning with the single table parameter, but it does not specify whether the value should be a table name, fully-qualified identifier, or display label, nor does it describe any formatting constraints. This is minimal compensation for a low-coverage 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 names a specific resource ('knowledge for a table') and enumerates concrete content components: purpose, column meanings, NL->SQL examples, and gotchas. It is clear what the tool does and, to some degree, what it returns, though it does not explicitly contrast itself with the sibling describe_table.

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

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

Usage context is implied: an agent would call this when it needs rich semantic context about a table rather than just its schema. However, there is no explicit guidance about when to prefer this over describe_table or search_knowledge, nor any exclusions or prerequisites such as requiring a table name from list_tables.

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. 'List' implies a read-only operation, but the description does not state whether it is safe/idempotent, what the output shape is, whether results are paginated, or any other behavior. More transparency would be needed 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?

The description is a single, front-loaded sentence with no wasted words. It is appropriately concise for a zero-parameter tool, though it borders on underspecified.

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 listing tool, the description covers the basic action and resource. However, with no output schema and no elaboration on what 'lens families' are or how this differs from list_tables, an agent may not fully understand the tool's place in the broader 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 tool has zero parameters, so there is nothing for the description to explain. The baseline of 4 applies because parameter semantics are not a concern.

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 a clear resource ('lens families and their tables'), which conveys what the tool does. It is somewhat differentiated from sibling tools like list_tables by the 'lens families' qualifier, though the term 'lens' is not explained.

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 for when to use this tool versus alternatives such as list_tables or describe_table. The description provides no context about selection criteria, prerequisites, or relationships to 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 of behavioral disclosure. It only states the basic action and an optional filter; it does not mention return format, pagination, ordering, or what 'purpose' means. There is no indication of side effects, but the read-only nature is implied by 'List' rather than explicitly disclosed.

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

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

The description is very short and front-loads the main verb and resource. Both sentences serve a purpose, though the second sentence is a sentence fragment. It is appropriately sized for such a simple tool, though the phrase 'with purpose' is slightly vague and could be clearer.

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 optional parameter and no output schema or annotations, the description is minimally viable: it states the core operation and the filter. However, it leaves the meaning of 'purpose' unspecified and does not mention that valid family values could come from list_families, so an agent may lack enough context to use it precisely.

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

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

Schema description coverage is 0%, so the description must compensate for the meaning of the 'family' parameter. It does so by calling it an 'Optional family filter', which clarifies that it is optional and serves as a filter. However, it does not specify how the filter matches (exact, partial, etc.) or where valid family values come from, leaving gaps.

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

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

The description uses a clear verb and resource: 'List catalog tables' tells the agent exactly what the tool does. The phrase 'with purpose' hints at what is returned, and the resource 'catalog tables' distinguishes it from siblings like list_families, though it does not explicitly name alternatives.

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

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

The description provides no guidance on when to choose this tool over siblings such as list_families or describe_table. It does not state prerequisites, exclusions, or scenarios where an alternative would be better. The only additional sentence is about the family filter, which is parameter guidance, not 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 available, the description carries the full burden of behavioral disclosure. 'Retrieve' implies a read operation, but the description does not explain behavior for missing keys, duplicate keys, exact matching, or the return format, which is especially important because there is no output schema.

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

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

A single seven-word sentence with no filler; the core action and object are front-loaded. It is appropriately concise for a simple lookup tool.

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

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

For a tool with no annotations, no output schema, and two required parameters, the description is too sparse. It omits failure behavior and return semantics beyond 'one value', and it does not relate the tool to the reference-table family of sibling tools.

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 table_id and key. It only implies their roles via 'reference table' and 'one value' without clarifying key format, whether matching is exact, or how table_id identifies a table.

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 clear verb ('Retrieve') and names the resource ('one value from a reference table'), so the core action is identifiable. However, it does not differentiate the tool from siblings like get_reference or search_lookups, and 'reference table' is left undefined.

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

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

There is no guidance on when to choose this tool over alternatives such as search_lookups, run_select, or get_reference. The description only states what the tool does, not when it should be preferred or when it should not be used.

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 behavioral burden. 'Find' implies a read-only lookup with no apparent side effects, which is useful baseline information. However, it does not disclose behavior for unknown model names, whether matching is exact or fuzzy, or what exact output shape to expect, leaving clear 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 sentence with no filler, and the action 'Find' is front-loaded. It is concise and easy to parse, though it sacrifices some supporting 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 one-parameter lookup tool with no output schema, the description gives the essential purpose and the kind of result ('table/family'), so an agent could attempt a first call. However, it lacks context about how to choose this tool over sibling lookup/search tools and what happens when no match is found, so completeness is only minimal.

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 generic 'name' string with 0% description coverage, and the tool description never explicitly says 'name is the lens model name.' Still, since 'name' is the only parameter and the description mentions 'a lens model,' an agent can reasonably infer the connection. No format, pattern, or case-sensitivity details are given.

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 names the resource ('which table/family a lens model belongs to'), clearly indicating a lookup/mapping operation. It does not explicitly differentiate itself from sibling lookup/search tools or define 'lens model,' but the core purpose is clear.

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

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

The description gives no guidance on when to use this tool instead of the many related siblings such as 'lookup', 'search_lookups', or 'get_reference'. No when/when-not conditions or alternative tool references are provided, so usage must be inferred from the name alone.

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

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

With no annotations provided, the description carries the full burden. 'Validated read-only' conveys that the tool will not mutate data and will validate the query, which is useful. However, it does not disclose what validation entails, potential error behavior, or return format, leaving gaps in 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, tight sentence with no filler. Both qualifiers ('validated' and 'read-only') add meaningful behavioral information, making it concise and effectively front-loaded.

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

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

For a one-parameter tool with no annotations or output schema, the description offers the essential 'this is a SELECT' context, but it lacks guidance on when to choose it over the numerous sibling lookup/search tools, and does not cover expected output or validation limits. The agent is left with significant ambiguity for correct usage.

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

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

The schema has a single 'sql' parameter with 0% description coverage, so the description must compensate. 'Run a validated read-only SELECT' clarifies that the parameter must contain a SELECT statement, which adds meaning beyond just 'string'. Yet it provides no further details on allowed syntax or formatting.

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 ('Run') and resource ('a validated read-only SELECT'), making it immediately clear that this tool executes SQL SELECT statements. It effectively distinguishes itself from the sibling tools, none of which mention SQL or direct query execution.

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

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

The description gives no explicit guidance on when to use this tool versus the many lookup/search siblings. It only implies through the word 'SELECT' that it is for SQL queries, but does not state conditions, 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?

No annotations are provided, so the description must carry the behavioral burden. The verb 'Find' implies a read-only search and the pipeline clarifies it does not calculate or retrieve directly, but the description does not disclose result format, ordering, or behavior when no calculators match.

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 plus a compact workflow arrow. It is front-loaded with the main purpose and contains no filler, though it is terse enough that some parameter guidance is omitted.

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 search tool, the purpose and next-step workflow are reasonably clear. However, with no output schema and no annotations, the description does not explain what the search result looks like or how top_k affects the response, leaving some inference burden on the agent.

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

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

Schema description coverage is 0%, so the description must compensate. It does connect 'query' to a natural-language question, but 'top_k' is not explained at all, and the description adds no detail about how results are ranked or filtered.

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 ('Find'), a clear resource ('optics calculators'), and the input style ('natural-language question'). The arrow to get_calculator and calculate clearly distinguishes this as the discovery step among its siblings.

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

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

The arrow '→ get_calculator → calculate' provides an explicit workflow: search first, then retrieve the calculator, then calculate. This gives clear context for when to use the tool, though it does not mention exclusions or when alternative search tools would be preferable.

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 behavioral burden. It indicates a search/discovery operation and a routing relationship to get_table_knowledge, but it does not disclose the result shape, whether multiple matches are returned, how top_k affects output, or any limitations.

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

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

The description is two short sentences with no filler. The action verb is front-loaded, and the arrow to get_table_knowledge is a compact, valuable routing instruction that 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 annotations and no output schema, the description is too thin. It leaves gaps around result semantics, top_k behavior, and usage context, and the close sibling search_knowledge_base is not distinguished. An agent would need additional inference to call it confidently.

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 for query by specifying it is a natural-language use-case question, but top_k is completely unexplained, and there is no information about ranking, filtering, or expected output.

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 names a clear resource: 'which table/family fits a use-case NL question.' It also points to get_table_knowledge as the natural follow-up, which helps orient the agent. However, it does not explicitly contrast itself with similarly named siblings like search_knowledge_base.

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

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

There is no explicit when-to-use or when-not-to-use guidance. The phrase 'use-case NL question' implies a natural-language discovery use case, and the arrow to get_table_knowledge suggests a routing pattern, but no alternatives or exclusions among the many sibling tools 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?

No annotations are provided, so the description carries the burden of behavioral disclosure. It does add useful return-format context ('ranked snippets + confident flag') that is not present elsewhere. However, it does not explain ranking behavior, the meaning of the confidence flag, pagination, or any read-only constraints.

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

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

The description is two short sentences with no filler. It front-loads the action and resource, then adds return-value detail. 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?

There is no output schema, so the description's mention of return data is valuable. However, with no annotations, no parameter semantics, and no usage guidance relative to several similarly named siblings, the description is not fully complete for an agent to reliably 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?

Schema description coverage is 0%, so the description must compensate, but it does not mention either parameter. 'Query' is inferable from the word 'Search', yet 'top_k' is completely unexplained in terms of its effect on results, default behavior, or acceptable values.

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

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

The description states a specific verb ('Search'), a clear resource ('EarthTekniks KB'), and the scope of that resource ('company, platforms, projects, vision fundamentals'). It also indicates what is returned ('ranked snippets + confident flag'), making the tool's core purpose clear. However, it does not distinguish this from the sibling 'search_knowledge' tool, which has a very similar name and likely overlapping function.

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

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

The description gives no explicit when-to-use or when-not-to-use guidance, and it does not mention any alternatives. With many sibling tools like 'search_knowledge', 'search_lookups', and 'get_reference', the agent is left to infer when this tool is the right choice rather than being directed.

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 says the tool finds reference/lookup tables and suggests downstream tools, but it does not disclose what the search returns, how results are ordered, whether matches are approximate or exact, or any pagination/limit behavior. This leaves important execution behavior unexplained.

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

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

The description is short and front-loaded with the core purpose, which is good. However, the '→ get_reference → lookup' notation is cryptic and interrupts the natural reading flow. It earns some value by suggesting follow-ups, but it is not presented in a clear, structured way.

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, no annotations, and 0% parameter documentation, the description alone must give an agent enough context to invoke the tool correctly. It provides examples and a follow-up chain, but it omits the return shape, result semantics, and how the query/top_k parameters affect behavior, leaving the tool incompletely specified.

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

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

Schema description coverage is 0%, and the description does not explain the 'query' or 'top_k' parameters directly. The examples ('sensor sizes, f-stops, pixel formats') weakly suggest what queries may contain, but the description does not clarify how top_k affects results or what format the query should take, so it does not sufficiently compensate for the missing schema documentation.

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

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

The description names a specific action ('Find') and a clear resource ('reference/lookup tables'), with concrete examples such as sensor sizes, f-stops, and pixel formats. This distinguishes it from general search tools and gives an agent a clear idea of the tool's domain, though the arrow notation adds mild ambiguity.

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

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

The description implies when to use this tool: when searching for reference/lookup tables rather than documents, calculators, or products. The 'get_reference → lookup' chain hints at the expected follow-up workflow, but there is no explicit statement of when not to use this tool or how it compares to alternatives like search_knowledge_base.

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 only says this is a 'filtered search' and sketches the filter shape, leaving out whether the operation is read-only, what happens with invalid filters, how results are ordered, or how limits behave.

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

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

The description is short, front-loaded with the core purpose, and contains no filler. The filter-format hint is useful, though the brevity leaves several parameters unexplained.

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 six parameters, no annotations, no output schema, and many similar sibling tools, the description is too sparse. An agent would still need to guess about valid filter operators, the meaning of sort/columns/limit, and whether table and family are mutually exclusive.

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 for 'filters' via the [{column, op, value}] shape and partially explains table/family scope, but it does not explain sort, limit, columns, valid operators, or how table and family relate.

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

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

The description states a clear action and scope: a filtered search over one table or family. It is more specific than the bare tool name, but it does not differentiate this tool from siblings like run_select, search_lookups, or search_knowledge_base.

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

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

There is no guidance about when to use search_products versus the many sibling search/query tools. The phrase 'over one table or family' hints at scope constraints, but it never says when this tool should be chosen or avoided.

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