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

With no annotations provided, the description carries the full burden of behavioral disclosure. It says the tool 'shows where the data came from and when sources were last checked,' which is some behavioral context, but it doesn't disclose what happens if the path doesn't exist, whether it's read-only (implied but not stated), how freshness is measured, or what the output structure looks like. For a read-info tool without annotations, this is a meaningful gap.

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

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

The description is a single, efficient sentence that fits all relevant information in one breath. It states the verb, resource, and the two key outputs (data origin and last-check timestamps) with zero wasted words. Well-structured and front-loaded.

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

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

For a simple one-parameter lookup tool with full schema coverage and no output schema, the description is mostly adequate. The main gap is behavioral — the tool doesn't explain failure modes or whether it's safe/read-only, which matters given the complete absence of annotations. It's a competent description but doesn't fully round out the usage story for an agent.

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

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

Schema description coverage is 100%, with the single data_path parameter documenting its format and providing three concrete examples ('pages.home', 'workflows.clock_in', etc.). The description's phrase 'where the data came from and when sources were last checked' slightly enriches understanding of what the parameter's lookup will return, but the heavy lifting is done by 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 tool gets provenance info for a data path and elaborates on what that means ('shows where the data came from and when sources were last checked'). The verb 'Get' plus resource 'provenance info for a data path' is specific and action-oriented. It doesn't explicitly distinguish from siblings by name, but the concept of provenance is unique enough among tools like get_table_schema, get_field, and get_page that differentiation is reasonably 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 provides no guidance on when to use this tool versus alternatives. It doesn't address when provenance matters (e.g., before trusting data, after data updates, for auditing changes) or when a sibling tool like get_field or get_table_schema would be more appropriate. The concept of provenance is implied to be for tracing data origins, but no explicit context or exclusions 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?

With no annotations provided, the description carries the full burden of behavioral disclosure. It doesn't state what happens if the operation is omitted (returns all endpoints for an entity?), whether the tool returns raw OpenAPI-style specs or simplified descriptions, or what error behavior occurs for unknown entities. Minimal behavioral context beyond the literal purpose.

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 of 9 words. It's appropriately short but arguably under-specified for a tool that has valuable usage nuance (optional operation parameter, entity name conventions). Concise but not complete — though this dimension rewards brevity and front-loading, which it achieves.

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 2 params, no output schema, and no annotations, the description is modest but basic. The absence of an output schema shifts burden to the description to indicate what an 'API endpoint specification' contains (URL, method, request/response shapes?), but it doesn't. For a tool with a large list of known entities and operations, some guidance about where these names come from would help. Adequate but has clear gaps.

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

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

Schema coverage is 100%, with both parameters well-documented via extensive example lists in the schema itself. The description adds the phrase 'by entity and operation' which mirrors the parameters but adds little value beyond the schema. Baseline 3 is appropriate since the schema already does the heavy lifting with concrete 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 the verb 'Get' and resources 'API endpoint specification' filtered by entity and operation. It distinguishes itself somewhat from siblings like get_table_schema and get_field by focusing on API endpoint specs, though it doesn't explicitly differentiate itself. The 'by entity and operation' qualifier adds useful specificity.

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

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

The description gives no when-to-use guidance or exclusions. It doesn't clarify when to use this over get_table_schema, get_field, or get_interaction_pattern. No mention of when 'operation' is required vs optional, or what happens if only entity is provided. The user must infer usage context from the parameter examples.

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 does not state whether this is a read-only safe operation, how much data is returned, whether the field must exist or what the error behavior is, or the granularity of the spec (single field vs. summary). For an unannotated tool with no output schema, this is a notable gap.

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

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

A single sentence that is front-loaded and efficient with zero waste. It names the resource, the action, and the key content categories immediately.

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 single-parameter lookup tool with 100% schema coverage, the description is mostly adequate. However, the lack of an output schema and absence of annotations means the description could usefully add return format details or note associations (e.g., 'use after get_table_schema' or 'returns the full spec in JSON'). It covers the essential purpose but leaves return-shape expectations unspecified.

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%, with the field_id parameter fully documented including example values. Per the rubric, this sets a baseline of 3. The description adds the context that the field spec includes component type, validation, and API mapping, which helps the agent understand what the field_id will be used to retrieve, but it doesn't add syntactic or format details beyond the schema.

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

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

The description states a specific verb+resource ('Get field-level specification') and lists the included content categories (component type, validation, API mapping). This is reasonably clear and distinct from siblings like get_validation_rules and get_api_endpoint, though the overlap with get_validation_rules isn't explicitly addressed.

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

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

No guidance is given on when to use this tool versus alternatives like get_validation_rules (which also covers validation) or get_api_endpoint (which covers API mapping). The description implies usage by enumerating content but provides no explicit when-to-use or exclusion guidance.

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

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

No annotations are provided, so the description carries the full burden of behavioral disclosure. It doesn't state whether this is a read-only lookup, what the return format is, whether the pattern is deterministic, or what happens when an invalid pattern_id is given. For a retrieval tool, the safety profile and failure behavior are undocumented.

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

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

The description is one terse sentence with no wasted words, which is efficient. However, it's under-specified rather than concise—the single sentence does minimal work and doesn't earn its place by providing useful context beyond the tool name.

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 1 parameter, 100% schema coverage, no output schema, and no annotations, the description should compensate for the missing behavioral and return-value context. It doesn't describe what an interaction pattern contains, what output shape to expect, or how it differs from get_api_endpoint and other sibling lookups. For a data-retrieval tool, this is incomplete.

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

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

Schema coverage is 100%, and the pattern_id description lists concrete example values ('metric_card', 'dialog', 'drawer', etc.), which is genuinely helpful. However, the description itself adds nothing beyond the schema—it doesn't clarify the format, case sensitivity, or how a user discovers valid pattern_ids. Baseline 3 is appropriate given the strong schema coverage.

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

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

The description 'Get UI component interaction pattern for automation' states a verb and resource, but it's vague—it doesn't specify what an interaction pattern is, what kind of automation it supports, or what domain/scope these patterns cover. The sibling tools (get_field, get_page, get_workflow) suggest a metadata/documentation system, but the description doesn't clarify how interaction patterns fit in that context.

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

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

No guidance on when to use this tool versus siblings like get_field or get_page. There's no exclusions or context about when an interaction pattern is needed versus other metadata lookups. The description doesn't mention any prerequisites or relationships to other tools.

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

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

With no annotations provided, the description carries the burden of disclosing behavioral traits. It states what is returned (fields, actions, sections, navigation context) which is genuinely useful. However, it doesn't disclose any details about read-only nature, error behavior for invalid page_ids, or whether partial specs can be returned. The content disclosure adds value but misses safety/edge-case behavior.

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

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

The description is a single compact sentence that states the purpose and the return contents. Zero wasted words, perfectly front-loaded with the primary action and target.

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 with a well-covered schema and no output schema, the description is reasonably complete. It names what the response contains (fields, actions, sections, navigation context), compensating for the lack of an output schema. Slight deduction for not covering error conditions or pagination behavior, though the simplicity of the tool mitigates this.

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

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

Schema description coverage is 100%, meaning the schema fully documents the page_id parameter with concrete example values. The description adds 'full page specification' context that clarifies the parameter selects the complete spec, not a fragment. Given perfect schema coverage, the baseline of 3 applies and the description's clarification of scope earns a 4.

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

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

The description uses a specific verb+resource ('Get full page specification by page_id') and lists the concrete content returned (fields, actions, sections, navigation context). It clearly distinguishes from siblings like get_field, get_table_schema, and get_workflow by indicating this returns the aggregate page-level spec.

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

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

The description implies the tool is for retrieving complete page specifications, not individual fragments (which is what get_field, get_transitions etc. handle). However, it doesn't explicitly state when to choose this over siblings or when it should NOT be used. The context is clear but no explicit exclusions or alternatives are named.

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 disclosure burden. It's a read operation by nature ('Get'), and the description's phrasing is consistent with a safe read. However, it doesn't disclose what happens when 'state' is omitted (presumably returns all permissions), the return format, or whether it returns actions/operations for the role at the given state. The description is adequate but adds little beyond what the name and schema already suggest.

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 concise sentence that gets straight to the point. No wasted words, no filler. It's appropriately front-loaded with the core purpose. Could arguably be slightly more informative (e.g., mention that omitting state returns all permissions), but as-is it's efficient and readable.

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

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

This is a relatively simple 2-parameter read tool with no output schema and no annotations. The description covers the basic purpose but omits details like default behavior when 'state' is absent, the nature of the returned permission data, and how this relates to the work order lifecycle. For a tool with an optional state parameter, it would be helpful to state what the default behavior is. Given its simplicity, the description is minimally adequate but leaves room for more 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?

Schema coverage is 100%, so both 'state' and 'persona' have descriptions in the schema. The description adds the semantic framing that state 'scopes permissions' to a 'given work order state', which slightly enriches the schema's mention of 'WO state to scope permissions'. However, it doesn't add meaningful new meaning beyond the schema — the baseline 3 is appropriate since schema does the heavy lifting and the description provides only marginal value (clarifying that the state is a work-order state).

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 'Get what a persona/role can do at a given work order state' uses a clear verb (Get) with a specific resource (persona/role permissions) and context (work order state). It's distinct from siblings like get_transitions or get_validation_rules, which focus on workflows and rules rather than role capabilities. It's clear but could sharpen by naming a specific output (e.g., 'permissions list') or confirming the subject is work-order permissions rather than generic system permissions.

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 states 'at a given work order state' which implies the state parameter scopes results, but it provides no explicit guidance on when to use this tool versus siblings. For example, it doesn't differentiate when someone should call get_persona_permissions vs get_transitions or get_validation_rules. There's no when/when-not guidance, just a general sense that this answers role capability questions.

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 states the tool reads a table definition, but doesn't disclose whether the schema is cached, whether it's a live query, what happens for invalid table names, or whether it includes all constraints/types. For a read operation with zero annotations, more disclosure would be expected.

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 concise sentence that conveys the core purpose and output. No fluff. Could arguably add a bit more context, but for a low-parameter read tool, the brevity is appropriate.

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 single-parameter read tool, the description is mostly sufficient. The output (columns and relationships) is stated. However, with no annotations and no output schema, it doesn't disclose potential error behavior (e.g., invalid table names) which could be relevant for agents. Given the simplicity, this is acceptable but not exceptional.

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% — the single parameter table_name has a description in the schema listing valid example values. The tool description itself adds no parameter detail beyond 'columns and relationships' for the output. Baseline 3 is appropriate since the schema already handles the heavy lifting for the one parameter.

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 'Get database table definition with columns and relationships' uses a specific verb (Get) with a resource (database table) and lists what's returned (columns and relationships). It clearly distinguishes from siblings like get_field (single field vs table) and get_api_endpoint. Could be slightly more explicit about the name-based lookup but 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 doesn't explicitly state when to use this tool vs get_field or other siblings. However, the context signal that the schema includes example table names provides implicit guidance for which resources this applies to. No exclusion criteria or alternative recommendation is given, so it's adequate but not strong.

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. The description establishes this is a read-only retrieval operation ('Get test fixture data') which signals non-destructive behavior. However, it doesn't disclose what a fixture returns, whether results differ by entity type, or any caveats about fixture completeness or staleness.

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, two distinct retrieval modes, zero filler. Every clause carries meaning - the purpose verb, the tool domain, and both access patterns are packed into a compact 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 read tool with 2 well-documented parameters and 100% schema coverage, the description is reasonably complete. The main gaps are the absence of any return-format indication and no mention of the context for when fixtures are appropriate (e.g., only for certain environments). No output schema exists to compensate.

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%, with both 'id' and 'entity' parameters having descriptive text in the schema itself, including concrete examples. The description adds the relationship between the two params (filter vs. retrieve by ID) but doesn't add format or syntax details beyond what the schema already provides. 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 'Get test fixture data for automation' with a specific verb (get) and resource (test fixture data). It adds filtering capabilities (by entity type or ID) that distinguish it from sibling get_* tools like get_api_endpoint, get_table_schema, etc., though it doesn't explicitly name these 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 implies usage for automation testing workflows and mentions two retrieval modes (filter by entity type, get by ID), but provides no explicit when-to-use guidance or exclusions versus sibling tools like get_workflow or get_table_schema. Sibling names are discoverable but no differentiation is stated.

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

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

With no annotations provided, the description carries the full burden of behavioral disclosure. It states the tool is read-only in nature by describing it as 'Get' transitions, which implies no side effects. However, it doesn't clarify whether this is a pure read operation, what happens with an invalid from_state value, or whether returned transitions include edge cases like self-transitions. Acceptable but thin on behavioral 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?

One sentence, zero waste. Front-loaded with the verb 'Get', immediately followed by the object and scope. 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 single-parameter tool with a clear purpose and 100% schema coverage, the description is mostly adequate. However, with no output schema and no annotations, there is no indication of what the return value looks like (array of strings? objects with fields?). The description would benefit from noting the response structure, but for this simplicity level it's minimally 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% for the single parameter (from_state), and the schema already documents example values ('PLANNING', 'PENDING', 'OPEN', 'WORK_FINISHED', 'CLOSED'). The description adds minimal value beyond the schema, mentioning 'from a given work order state' which mirrors the parameter name. Since schema does the heavy lifting, 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 states a specific verb and resource: 'Get valid status transitions from a given work order state.' It clearly indicates what the tool returns (valid status transitions) and the input (work order state). It doesn't explicitly distinguish itself from the sibling tool get_workflow, which might overlap, but the purpose itself is clear and specific.

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 (when querying possible next states from a work order state) but provides no explicit guidance on when to use this versus alternatives like get_workflow. There's no when-not-to-use or exclusionary language. The implication is present but not explicit.

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

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

No annotations are provided and the description gives no insight into behavior beyond the verb 'get'. It doesn't clarify whether rules are static data, computed, require auth, or what format they take. For a read operation with no annotation coverage, the description carries the full burden but adds essentially nothing beyond 'get rules'.

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

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

The description is a single concise sentence with zero waste. However, it is under-specified rather than efficiently concise - one short sentence that adds little information beyond the tool name itself.

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 100% schema description coverage for the single parameter and no output schema, the description doesn't need to explain parameters or return values. However, the tool retrieves validation rules - a potentially nuanced concept - and the description doesn't explain what these rules look like, how they're structured, or how they relate to the entity/operation. The sibling tools (get_workflow, get_table_schema, get_field) suggest a documentation/exploration toolkit, but the description doesn't distinguish or elaborate.

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 description adds no parameter info beyond what the schema already provides. The schema's entity description is quite detailed with examples. The baseline 3 is appropriate since the schema already handles the parameter well.

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

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

The description states 'Get validation rules for an entity or operation' - a clear verb+resource pattern. The 'or operation' phrasing adds helpful scope clarification. However, it doesn't distinguish from siblings beyond the 'rules' concept; 'get_table_schema', 'get_workflow', and 'get_api_endpoint' could all plausibly deliver validation-adjacent information.

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 names the two valid entity types ('entity or operation') but gives no guidance on when to use this tool versus alternatives like get_workflow or get_transitions, nor any exclusions or prerequisites. An agent must guess when validation rules are relevant versus other metadata lookups.

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

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

No annotations are provided, so the description carries the full burden of behavioral disclosure. The description says it returns 'a named workflow recipe with step-by-step instructions' but doesn't disclose whether the workflow is read-only, what happens if the workflow_id doesn't exist, how large the response is, or whether there are UI/automation side effects. For a getter with zero annotations, more behavioral context would be expected.

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

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

A single, efficient sentence that conveys the action and the nature of the return value without fluff. It front-loads the verb and resource. Slightly more could be added, but for a one-parameter getter it's compact and waste-free.

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 getter with 100% schema coverage and no output schema, this is fairly complete. The lack of an output schema and annotations means the description is the only source for return-value semantics; it states the output is step-by-step instructions, which handles the main gap. Given the tool's low complexity, the description is adequate but not rich.

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 single required parameter workflow_id already includes rich examples of valid identifiers in its schema description. The tool description itself adds 'named workflow recipe' context about the resource type, which slightly complements the schema but the schema already does the heavy lifting. 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?

Clear purpose: retrieves a named workflow recipe with step-by-step automation instructions. The verb 'get' + resource 'workflow' is specific, and the phrase 'named workflow recipe with step-by-step instructions for automation' distinguishes it from sibling tools like get_field or get_page, though no sibling is explicitly named.

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

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

The description implies this is for retrieving a pre-defined workflow recipe for automation, which is reasonably clear. However, there are no explicit when-to-use/when-not-to-use statements or alternatives named. Among the many 'get_*' siblings, nothing helps the agent disambiguate when to pick this over comparable getters.

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

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

No annotations are provided, so the description carries the full burden of behavioral disclosure. The description only lists data types searched but doesn't disclose whether it returns snippets, limits on results, ranking behavior, or how results are grouped/organized. For a broad search tool with zero annotation coverage, more behavioral context 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 concise sentence that names the tool function and enumerates the data categories it covers. No waste, appropriately sized for a search tool. It could optionally mention result format, but the current length is justified given the simple one-parameter 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 tool is simple (1 param, no output schema, no nested objects), and the description names the covered data types. However, without an output schema, describing how results are presented (grouped by entity type, unified list, count, etc.) would improve completeness. The breadth of data types covered makes the absence of result-format info a noticeable 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% for the single 'query' parameter, so the schema handles parameter documentation adequately. The description adds the context that the search spans multiple data types but doesn't add query syntax details (wildcards, operators, phrase search). With complete schema coverage, 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 a full-text search tool across all data types (pages, workflows, endpoints, fields, tables, etc.). It has a specific verb (search) and resource (all data categories). While it distinguishes itself from sibling tools which are all get_ retrieval functions, it doesn't explicitly differentiate how its scope compares to potential non-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?

The 'all data' scope implies a broad applicability, but there's no explicit when-to-use/when-not-to-use guidance or mention of alternative tools. The siblings are all specific get_ retrieval tools, so search is implied as the discovery entry point, but this isn't stated. Some guidance on how to navigate from search results to specific get_ tools would strengthen this.

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