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 does not mention that the tool is read-only, any required permissions, potential side effects, or rate limits. For a tool with no annotations, more transparency is needed.

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

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

The description is a single sentence, front-loaded with the core purpose, and contains no unnecessary words. Every part contributes to understanding the tool's function.

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

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

Given that there are no annotations and no output schema, the description is adequate but could be more complete. It explains what the tool returns (coverage per column, table-level tests, coverage %) but does not specify the format or structure of the response. For a simple tool, this is sufficient but not exemplary.

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 does not add additional meaning beyond what the schema already provides for the three parameters. The parameter descriptions in the schema are already clear, so the description adds no extra value.

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

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

The description clearly states the verb (get coverage), resource (dbt model), and the specific output (per-column tests, table-level tests, coverage %). It distinguishes from sibling tools like dbt-list-tests or dbt-get-test by focusing on coverage 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 implies usage for checking test coverage but does not explicitly state when to use this tool versus alternatives like dbt-list-tests or dbt-get-test. No guidance on when not to use 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?

No annotations provided, so the description carries full burden. It mentions grouping and ordering but does not clarify what 'chronic failure count' means, whether the operation is read-only, or any side effects. The behavior beyond the basic purpose is opaque.

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, 12 words, highly concise. However, the brevity sacrifices some informational depth that could aid usability. For a simple tool, this is acceptable but could be improved.

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, the description should hint at return format or structure. It does not mention what the output looks like (e.g., list of tests with counts). The chronic failure grouping and ordering are mentioned but not explained. Incomplete for an agent to fully understand usage.

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

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

Schema coverage is 100%, so baseline 3 applies. The description adds no parameter-specific information; it does not reference recentRuns or extractFields. The schema itself provides adequate definitions, so the description adds no extra 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 it finds failed tests across N runs, grouped and ordered by chronic failure count. This distinguishes it from siblings like dbt-list-tests (lists all tests) and failed-tests-summary (likely summarizes, not grouped by chronicity).

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

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

No guidance on when to use this tool versus alternatives like dbt-list-tests or dq-failed-checks-by-dataset. The description implies a specific use case (chronic failures) but does not explicitly state when not to use it or mention 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?

Without annotations, the description carries the full burden. It discloses the return types (signature, raw SQL, reverse-lookup) but does not mention read-only nature, authentication, rate limits, or any side effects. The description is adequate but not rich in behavioral context.

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

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

The description is a single, front-loaded sentence that efficiently conveys the tool's purpose and output. Every word earns its place with no fluff.

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

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

Given the complexity (3 parameters, no output schema, no annotations), the description covers the core functionality well. It could elaborate more on parameter usage, but the schema descriptions handle that. The reverse-lookup aspect is a nice extra detail.

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 does not add extra meaning beyond what the schema already provides. For instance, it doesn't clarify the relationship between 'name' and 'uniqueId' or how 'extractFields' reduces tokens.

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 verb 'Get' and resource 'dbt macro' and specifies the exact outputs: signature, raw SQL, and reverse-lookup of nodes that call it. This differentiates it from sibling tools like dbt-get-model or dbt-get-source which have different resources and outputs.

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

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

The description provides no guidance on when to use this tool versus alternatives. For example, it doesn't explain when to use 'name' vs 'uniqueId' parameters, or how this differs from dbt-list-macros which lists all macros. No when-not-to-use or alternative tool mentions.

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?

Description mentions response contents but does not disclose additional behavioral traits such as read-only nature, authorization needs, or rate limits. No annotations provided, so description carries full burden but provides moderate 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?

Single sentence efficiently conveys purpose and response contents. Every word adds value; 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?

Four parameters well-described, but no output schema and no annotations. Description explains what the tool returns (refs, sources, etc.) but lacks details on error handling, prerequisites, or response format. Given complexity, 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 has 100% coverage with descriptions for all 4 parameters. The description does not add significant meaning beyond schema, but the overall context helps interpret parameter purpose. 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?

Description clearly states verb 'Get', resource 'single dbt model', and enumerates included elements (refs, sources, columns, tests, SQL). This distinguishes it from sibling tools like dbt-list-models and dbt-get-source.

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

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

No guidance on when to use this tool versus alternatives. Implicit from name and sibling tools that it is for fetching one model, but no explicit when-not-to-use or prerequisite information.

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, and the description does not disclose behavioral traits such as authorization needs, rate limits, or safety. The word 'Get' implies a read-only operation, but explicit safety disclosure is absent.

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 with no wasted words, effectively front-loaded with the core 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 description is minimal and fails to cover parameter usage, output format, or edge cases. Given the lack of annotations and output schema, more contextual completeness is needed for correct tool invocation.

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

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

The schema already describes 3 of 4 parameters (status, invocationId, extractFields) with 75% coverage. The description adds no additional meaning for any parameter. The `limit` parameter lacks a schema description and is not addressed in 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 clearly states the tool returns per-node results from a dbt invocation, distinguishing it from sibling tools that retrieve single objects or run lists. However, it does not explicitly name these alternatives, so it falls short of a 5.

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

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

The description implies usage context by noting that omitting invocationId retrieves the latest run, but it provides no explicit guidance on when to use this tool versus alternative sibling tools like dbt-list-runs or dbt-get-model.

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 provided, but description indicates a read operation with no destructive side effects, detailing what is returned (freshness criteria, columns, latest freshness result). Full burden is met for a simple get.

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 that is front-loaded with purpose and contains no redundant information; 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?

Description covers what the tool retrieves (freshness criteria, columns, latest freshness result). Lack of output schema is mitigated by describing return content. Minor gap: no mention of error conditions or empty 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% with descriptions for all 4 parameters. Description adds overall context on tool output but does not enhance meaning beyond schema for individual 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?

Description clearly states 'Get a single dbt source' and specifies returned fields (freshness criteria, columns, latest freshness result), distinguishing it from sibling tools like dbt-list-sources.

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

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

Description implies usage for retrieving details of a specific source, but does not explicitly state when to use it versus alternatives or when not to use it.

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

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

With no annotations, the description carries full burden. It implies a read-only operation ('Get') but does not explicitly state idempotency, permissions, or side effects. It adds some behavioral context by listing what the response contains, but does not cover potential errors or cost implications.

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 of 11 words concisely conveys the tool's purpose and output. Every word is informative and front-loaded, with no redundancy or extraneous details.

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 (2 params, no output schema), the description adequately covers what the tool returns (definition, parameters, models, run result). It is complete enough for a 'get single entity' tool, though it could mention error handling or typical response structure.

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 input schema already provides detailed descriptions for both parameters (uniqueId with example, extractFields with usage). The description adds no additional parameter information beyond the schema, so 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 the tool retrieves a single dbt test, listing specific components returned (definition, parameters, attached models, latest run result). It uses a specific verb 'Get' and distinct resource 'single dbt test', differentiating it from sibling tools like dbt-list-tests (list) and dbt-failed-tests (subset).

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 dbt-list-tests for listing or dbt-failed-tests for failures. The description implies use for detailed retrieval of a specific test but lacks when-not-to-use or prerequisite information.

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 provided, so description should disclose behavioral traits. It states it 'walks' and 'returns' but does not mention side effects (e.g., read-only), rate limits, or authorization needs. The description is insufficient for an agent to know if the tool modifies state.

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 that encapsulates core functionality efficiently. Front-loads the action and return value. No extraneous words, earning 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?

Despite simplicity, the description lacks context on how results are structured (no output schema), dependencies on parent_map/child_map, and the role of extractFields parameter. Incomplete for a tool with multiple parameters and no output schema.

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

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

Parameter descriptions in the input schema are detailed (e.g., extractFields has extensive documentation). The tool description adds little beyond noting depth limits, so it does not significantly enhance parameter understanding. Baseline 3 due to moderate 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?

Description clearly states action (walking), resource (dbt parent_map/child_map), and return (upstream/downstream nodes up to given depth). It effectively distinguishes from sibling tools like dbt-get-model or dbt-get-source which retrieve single entities.

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 exploring node dependencies but does not provide explicit guidance on when to use this tool versus alternatives, nor does it mention when not to use it. No mention of prerequisites or 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 holds the burden for behavioral disclosure. It correctly identifies the tool as a read operation (list), but does not elaborate on pagination behavior, impact of the 'limit' parameter, or whether authentication is required. Minimal but acceptable for a simple list tool.

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

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

The description is a single, clear sentence with no extraneous words. It efficiently conveys the core 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 description covers the basic purpose but is lacking in completeness. It does not hint at the output structure (e.g., list of exposure objects with properties), nor does it explain how the 'search', 'exposureType', or 'extractFields' parameters work. Given no output schema, more context would be beneficial.

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 75% (3 of 4 parameters have descriptions in the input schema). The tool description adds no additional information about parameters beyond what the schema already provides. Baseline is 3 due to high coverage.

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

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

The description clearly states the action ('List'), the resource ('dbt exposures'), and provides context that they are downstream consumers declared in YAML. This distinguishes it from sibling tools like dbt-list-models or dbt-list-sources.

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 (e.g., dbt-list-models, dbt-graph). There is no mention of prerequisites, typical use cases, or situations where it should be avoided.

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 the tool reads from 'manifest.json' and applies filters, implying a read-only operation. However, it does not disclose auth requirements, whether it accesses local files or remote endpoints, or the treatment of the default limit parameter. The core behavior is adequately communicated but not thoroughly.

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, short sentence that conveys the essential information without any superfluous words or tangential details. It is front-loaded and 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?

Given the tool's low complexity (4 params, no output schema, no required params) and the presence of well-described siblings, the description covers the primary behavioral aspects: what it lists, the source, and available filters. It is nearly complete, though it could mention the default limit or how results are ordered. Still, it meets the needs for a simple list tool.

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

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

The description adds context (source from manifest.json, filter types) beyond the schema, which already provides descriptions for 3 of 4 parameters. The semantic value is moderate: it clarifies the purpose of search and package filters but omits any mention of the 'limit' parameter, whose schema lacks a description. Overall, it adds some meaning but not deeply.

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

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

The description clearly states the action ('List'), the resource ('dbt macros'), the source ('manifest.json'), and available filters ('package / name'). This effectively distinguishes it from sibling tools like dbt-list-models, which list different resources.

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 vs alternatives (e.g., dbt-get-macro for a single macro, or other list tools). The description does not include when or when not to use it, nor does it reference prerequisites or behavior under different 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 transparency burden. It correctly implies a read-only operation ('list') but does not disclose whether results are paginated, what permissions are required, or how the manifest.json is accessed. The description is adequate but not comprehensive.

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

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

The description is a single efficient sentence with no superfluous words. It front-loads the verb and resource, and lists filters succinctly.

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 7 well-documented parameters but no output schema, the description misses explaining what the response contains (e.g., model metadata fields). It covers the filtering purpose but lacks completeness for an agent to fully understand the output structure.

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 detailed parameter descriptions. The description provides a high-level summary of filters but adds little meaning beyond the schema. 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 clearly states the verb 'List' and the resource 'dbt models', and enumerates the filtering dimensions (package, tag, materialized, schema, name search), making it distinct from sibling tools like dbt-list-tests or dbt-list-sources.

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

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

No guidance is provided on when to use this tool versus alternatives such as dbt-get-model for a single model or dbt-list-exposures. There is no mention of prerequisites, optimal scenarios, or exclusions.

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

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

No annotations are provided, so the description carries the full burden. It mentions reading from run_results.json but does not disclose whether it is read-only, whether multiple directories are scanned, error handling, or any safety concerns. Minimal behavioral disclosure.

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?

Very concise—one sentence that directly states the tool's function. No unnecessary words 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, the description should hint at what information is returned (e.g., list of run objects with timestamps, status). It does not. It also lacks information about input requirements or behavior. Incomplete for a list 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 50% (extractFields has a description, limit has default/min/max but no description). The tool description adds nothing about parameters; it relies on the schema. No additional semantics beyond the schema's hints.

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

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

The description clearly states the tool lists recent dbt invocations from specific files (run_results.json). It uses a specific verb 'List' and identifies the resource. However, it does not explicitly differentiate from sibling tools like dbt-get-run-results, but the purpose is still 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?

There is no guidance on when to use this tool versus alternatives. No mention of prerequisites, context, or exclusions. The description simply states what it does without usage advice.

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

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

Annotations are absent, so the description carries full burden for behavioral disclosure. It only states it lists sources from manifest.json but does not disclose whether the manifest is locally available, if authentication is needed, or any side effects (e.g., read-only). The description fails to communicate traits beyond the basic action, making it minimal.

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

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

The description is a single concise sentence that front-loads the action and resource. Every word is informative with no redundancy. It fully meets the requirement of being appropriately sized and 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?

Given the complexity (4 parameters, no output schema, many sibling list tools), the description is too brief. It does not explain the return format or contents, nor does it clarify when to prefer this over dbt-get-source or other list tools. The omission of output and comparative guidance makes it incomplete for effective tool selection.

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 high (75%), so the baseline is 3. The description adds 'optional source-group / name filters' which roughly maps to sourceName and search parameters, but provides no new details beyond the schema. It does not elaborate on limit or extractFields. The added semantic value is marginal, keeping the score at baseline.

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 specific action (List) and resource (dbt sources from manifest.json), which clearly differentiates it from siblings like dbt-list-models or dbt-list-tests. The mention of 'optional source-group / name filters' indicates filtering but could be slightly ambiguous—'source-group' maps to sourceName parameter and 'name' to search. Overall, purpose is clear with a specific verb and resource.

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

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

No guidance is provided on when to use this tool versus alternatives like dbt-get-source for a single source, or other list tools. There are no explicit context or exclusion statements. The description is purely declarative, leaving the agent to infer usage without comparative information.

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 only states the action ('list') without disclosing side effects, pagination, rate limits, or any behavioral traits. The limit parameter suggests pagination but is not explained.

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 without redundant information. It is concise and front-loaded. However, it could be slightly more structured (e.g., listing parameters or use cases) without adding length.

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 parameters, no output schema, and no annotations, the description is insufficient. It does not explain return value structure, pagination behavior, or how to effectively use the 'extractFields' parameter. Sibling tools are not differentiated, leaving the agent confused about when to use this tool.

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

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

The description does not add meaning beyond the input schema. With 60% schema description coverage, the description should compensate for missing parameter explanations, but it does not elaborate on any parameter. The 'extractFields' parameter, which is crucial for token reduction, is not mentioned.

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

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

The description clearly states the verb 'list', the resource 'dbt tests', and specifies that it can be filtered by test kind (generic, singular) and optionally to a specific model, distinguishing it from sibling tools like dbt-list-models or dbt-get-test.

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 dbt-get-test for single test details or dbt-list-models for models. The description does not mention prerequisites, limitations, or which tool to prefer under different 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 full burden. It discloses return of per-axis values and caveats for missing fields/artifacts, which is useful. However, it does not mention whether the tool is read-only or requires specific permissions, lacking full behavioral transparency.

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

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

Single sentence that conveys purpose, inputs, outputs, and edge cases. Efficient and well-structured.

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

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

For a simple tool with one parameter and no output schema, the description provides sufficient context: it explains the comparison, thresholds, and return fields. Minor gap: does not describe the 'caveats' in detail.

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

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

Only one parameter (extractFields) with 100% schema description coverage. The description adds no extra semantics beyond the schema, so 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 clearly states it compares two pass rates against thresholds from DBT_SLA_CONFIG_PATH and lists specific return fields. It distinguishes from siblings like dbt-coverage and freshness-status by its specific focus on SLA thresholds, but does not explicitly state the use case (e.g., 'check if SLAs are met').

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

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

No guidance on when to use this tool versus siblings like dbt-coverage or freshness-status. The description does not provide context about when to prefer this tool 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 is the sole source of behavioral information. It states the tool reads from a dbt run and returns a list, but does not disclose if it is read-only, permissions needed, or any rate limits. Critical behavioral traits 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 a single sentence that is concise and front-loaded, containing only essential information without extraneous details.

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 and lack of output schema or annotations, the description is adequate but incomplete. It does not mention how to use invocationId or extractFields, nor explain response format. Additional 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 covers two of three parameters (invocationId, extractFields) with descriptions. The topN parameter is inferred from the tool's purpose but lacks explicit schema description. The tool description adds minimal value beyond the schema, so a 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 clearly communicates that the tool returns the top N slowest models from a dbt run, sorted by execution_time. However, it lacks an explicit verb like 'list' or 'get', and while it distinguishes from sibling tools by focusing on slow models, it could be more precise.

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

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

No guidance is provided on when to use this tool versus alternatives such as dbt-list-models or dbt-get-model. The description does not mention appropriate contexts 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?

No annotations provided, so description carries full burden. It discloses that it groups by dataset, limits to 5 failures per dataset, and uses a recent window (via sinceHours). However, it does not explicitly state that it is read-only or describe potential side effects, leaving some behavioral questions unanswered.

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 that is concise, front-loaded with the action, and contains no unnecessary words. Every part 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?

For a tool with 3 parameters, no output schema, and no annotations, the description is minimally complete. It explains the grouping and time window but lacks details on output format, error handling, or how to choose among many similar 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 only 33% (extractFields described). Description adds no detail about topN or sinceHours parameters beyond what schema provides. It mentions 'recent window' and 'latest 5 failures per dataset' but these are output behaviors, not parameter semantics.

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

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

Description clearly states it groups failing checks by dataset, uses a recent window, and shows latest 5 failures per dataset. This distinguishes it from sibling tools like dq-list-checks (listing without grouping) and dq-get-check-history (history per check).

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. The description implies its purpose but does not specify when not to use it or mention related tools for similar tasks among many dq- siblings.

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

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

No annotations are present, so description must convey behavioral traits. It mentions time-series and days but lacks details on pagination (limit parameter), data freshness, or any side effects. The description does not compensate for missing 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 sentence, concise but overly brief. It misses important details that could be included without excessive length.

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 four parameters and no output schema, the description is insufficient. It does not explain the return format, how days and limit interact, or how extractFields works.

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 50% schema coverage, the description adds no extra meaning to parameters. The schema provides a detailed description for checkName, but days, limit, and extractFields are not elaborated in the description.

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

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

The description clearly states it provides a time-series of one check's status over days, distinguishing from siblings like dq-failed-checks-by-dataset or dq-score-trend. However, it does not explicitly define 'status' and relies on the tool name for the verb 'get'.

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 such as dq-list-checks or dq-score-snapshot. The description does not provide any context for selection among siblings.

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

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

No annotations provided, so description carries full burden. Mentions 'recent rows' but doesn't clarify default time window or explain that it's a read-only operation. Lacks details on authorization or performance.

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, focused, no unnecessary words. Could include more detail but remains 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?

With 6 parameters, no output schema, and no annotations, the description is minimal. It does not explain return format, pagination, or the meaning of 'recent' beyond the sinceHours parameter.

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 67% (4/6 parameters described). Description adds context that filters apply to DQ_RESULTS_TABLE, but does not significantly expand on parameters like limit or sinceHours beyond defaults.

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 it lists recent rows from DQ_RESULTS_TABLE with filters by dataset, status, type, and time window. It distinguishes from siblings like dq-failed-checks-by-dataset and dq-get-check-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?

Implies usage for listing recent checks with filters, but no explicit when-to-use or when-not-to-use compared to siblings like dq-failed-checks-by-dataset or dq-get-check-history.

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 discloses it combines outputs from three sub-tools but doesn't state whether it makes independent API calls, or any side effects. It is read-only by implication. Reasonable transparency, but could explicitly state it is non-destructive.

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?

Description is one sentence clearly conveying the composite nature. Very concise. Could benefit from a second sentence explaining typical use case, but front-loads key info effectively.

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 composite nature, the description sufficiently explains what the tool returns (aggregation of three sub-results). It misses mention of how the aggregation is structured (e.g., merged JSON), but the intended behavior is clear for an AI 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 has 3 parameters (days, extractFields, includeFailing) with 67% description coverage. The description does not add new meaning beyond the schema. Per rules, baseline 3 is appropriate since schema already explains parameters adequately.

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 the tool aggregates three specific sub-tools' outputs (score trend, tier compliance, failing checks). It clearly differentiates from siblings like dq-score-trend (single axis) or dq-tier-status (single component) by naming the combined result.

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 what the tool does but provides no guidance on when to use it vs. calling the individual sub-tools (dq-score-trend, dq-tier-status, dq-list-checks) or alternatives. It implies it is a convenience composite but doesn't specify scenarios where the composite is 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 bears the full burden of behavioral disclosure. It does not mention ordering, aggregation period, pagination, or any side effects. For a time-series tool, critical behaviors like default time range and data granularity 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 a single concise sentence that is front-loaded with the key concept (time-series of scores). It is efficient but lacks additional context that could be added without becoming verbose.

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 3 parameters and no output schema, the description is insufficient. It does not explain default behavior (e.g., how far back the time-series goes), what the response looks like, or how parameters like 'scope' and 'extractFields' affect the output. Users are left guessing essential details.

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

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

Schema coverage is 67% (2 of 3 parameters have descriptions). The description does not add meaning beyond schema: the tool description mentions the source table but not parameter usage. The missing 'days' parameter description is not compensated by 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 clearly states the tool returns a time-series of specific DQ scores (completeness, freshness, validity, anomaly_free, and overall_score) from a named source table. It distinguishes from siblings like dq-score-snapshot (snapshot vs. time-series) and dq-failed-checks-by-dataset (different focus).

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

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

No guidance on when to use this tool versus alternatives like dq-score-snapshot or dq-failed-checks-by-dataset. The description does not provide context for appropriate usage or scenarios where other tools might be preferred.

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 provided; description fully carries burden. It discloses data sources, fallback defaults, rollup logic, and caveats like untiered sources. Lacks authorization or rate limit info, but acceptable for read-only rollup.

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, front-loaded with purpose, no redundancies. Each 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?

Explains core logic and parameter implications well, but with no output schema, it omits return format, which could aid agent understanding. Adequate but leaves a 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?

Schema coverage is 100%, so baseline is 3. Description adds high-level context (e.g., mode distinction) but does not extend parameter meaning beyond schema definitions.

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 per-tier rollups from quality_checks grouped by source, with specific verb and resource. It distinguishes from siblings like dq-tier-status by detailing the source-to-tier mapping.

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 source vs table mode, but does not explicitly exclude cases or reference alternatives. It provides context but lacks direct when-not 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 provided, but the description explains the main behavior (comparison, default targets, override options, fallback for missing rows). It does not mention read-only nature or side effects, but these are implied.

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 that is front-loaded and concise, containing all key information without wasted 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?

Adequate for a simple tool with 3 parameters and no output schema, but lacks details about return format or structure. Could be improved by briefly describing the output.

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%, baseline 3. Description adds meaningful context beyond field descriptions, such as explaining the fallback logic for fallbackMaxDays and default behavior for date.

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

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

Clearly states the verb (compare/report) and resource (today's overall_score per scope against Tier SLA targets). Distinguishes from siblings like dbt-sla-status by focusing on tier-specific SLA compliance.

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 context for when to use: comparing scores against tier SLA targets with defaults and override methods. Does not explicitly exclude alternatives or specify when-not-to-use, but the context is sufficient.

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 aggregated nature, the 24h-ish time window, and that it includes the most recent failing rows. However, it does not explicitly state side effects, auth requirements, or whether it is read-only. For a composite tool, a bit more detail on behavior would be beneficial, but what is provided is adequate.

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: the first introduces the aggregated view and grouping, and the second explains that it replaces multiple tool calls. Every word earns its place; no fluff. Front-loaded with 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 the tool's complexity (composite with 3 parameters, no output schema), the description provides a good overview: aggregation, grouping by dataset, time window, and replacement of multiple calls. It could have included a bit more detail on the exact structure of the response, but for a 3-param tool it is largely 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%, with each parameter having a clear description. The tool description does not add additional meaning beyond what the schema already provides; it only mentions defaults implicitly. Therefore, 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 clearly states what the tool does: it aggregates dbt failed tests and DQ check failures grouped by dataset with the most recent failing rows. It explicitly distinguishes itself from siblings by noting it replaces three separate tool calls (dbt-failed-tests, dq-failed-checks-by-dataset, dq-list-checks), making its composite nature 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 explicitly states that this tool replaces 3+ separate tool calls, giving strong guidance on when to use it (when a consolidated view is needed). It does not provide explicit exclusions or when-not conditions, but the context is clear enough for an agent to infer appropriate usage.

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 provided, so the description carries full burden. It mentions 'cross-reference' but doesn't disclose what data is accessed, potential side effects, or staleness criteria. For a read-only query tool, more detail on behavior is needed.

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

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

Single sentence is concise and front-loaded with the primary action. However, it lacks structure like separate usage or behavior sections, but remains 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 simple query tool with two optional params and no output schema, the description covers core purpose. However, it lacks details on staleness criteria, prerequisites, or return format, leaving 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 coverage is 100% with descriptions for both parameters. The description adds meaningful context beyond schema: 'failingOnly' limits to warn/error, and 'extractFields' explains the project pattern including wildcard and backtick usage.

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

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

The description clearly states it answers 'is anything stale right now?' by cross-referencing dbt source freshness, but it doesn't differentiate from sibling tools like dbt-sla-status or dbt-list-sources.

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 (e.g., dbt-sla-status, dbt-list-sources). The implication is for staleness checks, but no when-not-to or context provided.

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

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

With no annotations provided, the description carries full burden. It mentions it returns dbt definition, test failures, and DQ checks, but does not disclose behavioral traits like read-only status, error handling (e.g., if both modelName and sourceFqn are provided), or any side effects. It provides moderate transparency but lacks detail.

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: the first defines the content, the second states the purpose. No extraneous words, every sentence earns its place. It is well-structured and front-loaded with 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 the tool has 4 parameters, no output schema, and no annotations, the description is somewhat incomplete. It covers the purpose and output scope but lacks details on return format, error handling, or what happens when the asset is not found. For a complex tool combining multiple data sources, more contextual information would be beneficial.

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 75% (three out of four parameters have descriptions). The description adds context by stating 'single asset deep-dive' implying modelName or sourceFqn anchors the query, but it does not explain sinceHours or extractFields. The schema already covers the purpose of the parameters, so the description adds minimal value beyond the schema.

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

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

The description clearly states the tool's function as a single asset deep-dive combining dbt definition, recent test failures, and DQ checks. It is designed for LLM-driven incident triage, which differentiates it from sibling tools that focus on individual aspects like dbt-get-model or dq-failed-checks-by-dataset.

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 tool is designed for incident triage, giving context for when to use it. However, it lacks explicit guidance on when not to use it or how to choose between similar tools (e.g., dbt-get-model vs this). The phrase 'anchor an LLM-driven incident triage' implies a comprehensive investigation context.

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

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

No annotations are provided, so the description carries the full burden for behavioral disclosure. It describes the tool's purpose (search/discovery) but does not explicitly state that it is a read-only operation or any other behavioral traits (e.g., no side effects, no data modification). The description adds minimal context beyond the immediate function.

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 front-loads the purpose. Every word is necessary and there is no extraneous information. It is optimally concise.

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 (search/discovery) and the absence of an output schema, the description is adequate. It explains what the tool does and when to use it. However, it could be slightly more complete by hinting at the output format (e.g., a list of tool names) to fully inform the agent, but overall it suffices.

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 does not add extra meaning beyond the parameter names and hints in the schema. It mentions 'natural language query' and 'categories' but these are already reflected in the 'query' and 'category' parameter descriptions. No new 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 'Discover available dbt MCP tools by natural language query across dbt / quality / meta categories' clearly states the verb (discover), resource (tools), and scope (cross-category). It distinguishes the tool from its siblings, which are specific operational tools like dbt-coverage or dq-failed-checks.

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 includes explicit guidance: 'call this first to find the right tool.' This tells the agent when to use it (before other tools) but does not specify when not to use it or name direct alternatives. The instruction is clear but lacks exclusionary context.

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