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

With no annotations provided, the description carries the full burden of disclosing behavioral traits. It does not state that the operation is read-only, does not mention permission requirements, and does not describe behavior for missing functions or invalid inputs. The description is minimal and lacks context about side effects or safety.

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

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

The description is a single, front-loaded sentence with no filler words. It efficiently communicates the tool's action and target resource.

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 with two parameters and an output schema, so the description doesn't need to detail return values. However, it omits any context about error handling, permissions, or when to use this tool over siblings. Given the output schema exists and the core behavior is clear, it is minimally complete but lacks contextual richness.

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

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

The input schema has zero description coverage for its two parameters. The description mentions 'by name' which partially covers function_name, but does not explain schema_name or clarify that both are required to uniquely identify a function. This leaves the parameters under-explained.

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

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

The description uses the specific verb 'Return' and identifies the resource as 'full source code (CREATE FUNCTION) of an RPC/function', clearly distinguishing it from sibling tools like functions_list that enumerate functions. It also specifies the lookup by name, making the tool's purpose unambiguous.

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

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

The description provides no explicit guidance on when to use this tool versus alternatives such as functions_list, nor does it mention any prerequisites or exclusions. The only implied use case is obtaining a single function's definition, but no direct comparison or conditions 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 burden of behavioral disclosure. It reveals the special 'all' value for schema_name and indicates that the output includes signature and return type. However, it does not explicitly state that the operation is read-only or mention any permission requirements, though 'list' implies a non-mutating action.

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

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

The description is one concise sentence with two clauses, communicating the purpose and key parameter behavior without any filler. Every word earns its place.

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

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

For a simple tool with one parameter and an output schema, the description covers the core purpose and parameter semantics. It lacks sibling differentiation and explicit confirmation of no side effects, but these are not critical for a basic list operation.

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

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

Schema coverage is 0%, so the description must compensate. It explains the schema_name parameter's special 'all' value, giving it meaningful context beyond the schema's default of 'public'. This adds direct value for a single-parameter tool.

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

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

The description uses a specific verb ('List') and resource ('Postgres functions') with clear output details ('signature, return type'). It does not explicitly differentiate from sibling tools like functions_list_rpc_candidates or functions_get_definition, but the name and scope make the primary purpose unambiguous.

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

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

No guidance is provided on when to use this tool versus related siblings such as functions_list_rpc_candidates or functions_get_definition. The only usage hint is the schema_name='all' special value, which is more about parameter behavior than tool selection.

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

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

With no annotations provided, the description carries full responsibility for behavioral disclosure. It merely says 'List candidates' without explaining what makes a function an RPC candidate, filtering logic, or output behavior. This lack of detail leaves the tool's behavior 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?

The description is a single sentence that front-loads the core purpose and includes a practical parameter tip. It is concise and free of fluff, though a bit more detail would not hurt.

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 relatively simple with one parameter and an output schema, but the description lacks context on what an 'RPC candidate' is and how this tool relates to 'functions_list'. Without annotations or usage guidelines, an agent may not fully understand when to invoke it, but the minimal scope prevents a lower score.

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

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

The schema shows one optional parameter with a default, but its description coverage is 0%. The description adds a useful hint that schema_name='all' lists all schemas, which is valuable beyond the schema. However, it does not elaborate on the parameter's full semantics or expected value format.

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 'List' as a specific verb and identifies the resource as 'Supabase RPC-callable function candidates'. It clearly states the primary action and target, though it does not explicitly distinguish from the sibling tool 'functions_list'.

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

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

No guidance is given on when to use this tool versus the similar 'functions_list' or other siblings. The only hint is about the schema_name parameter value 'all', which is parameter usage, not usage context.

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

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

With no annotations provided, the description carries the full burden. It uses 'List' to imply a read-only operation and discloses the 'all' behavior for schema_name, but it does not elaborate on permissions, error conditions, or return format, which is a gap given the absence of 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?

Two short, front-loaded sentences with no wasted words. The purpose and key usage variation are stated efficiently, and every part earns its place.

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

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

For a single-parameter list tool with an output schema, this description is reasonably complete. It states what is returned (foreign keys with from/to table and columns) and handles the 'all' case. It lacks depth on error handling or permission requirements, but that is acceptable for a simple read-only metadata tool.

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

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

Schema description coverage is 0%, so the description must compensate. It adds the crucial 'all' special value for schema_name, but does not explain other parameter semantics or potential values beyond what the schema provides. The schema already gives the default 'public', so the description adds marginal 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 'List foreign keys (from/to table and columns)' clearly identifies the resource and action, distinguishing it from sibling tools like relationships_list_indexes and triggers_list. It is specific and unambiguous.

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

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

The description gives a clear usage hint: schema_name='all' for all, which guides the agent on how to use the sole parameter. It does not explicitly mention when not to use this tool or alternatives, but the context is clear enough for a metadata listing tool.

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

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

No annotations are provided, so the description carries the full burden. It discloses the special `schema_name='all'` behavior, which is a useful scoping detail. However, it does not explicitly state that this is a read-only operation, nor does it mention potential edge cases like empty results or system indexes. Still, the behavior is simple and not misleading.

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

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

The description is two short sentences, front-loaded with the main action and output details. Every sentence earns its place, with no redundant information.

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

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

For a simple list tool with optional parameters and an output schema, the description covers the core functionality and the key special case. The main gap is the lack of explicit mention of `table_name` filtering, but the output schema and schema defaults fill in some details. Overall, it is complete enough for an agent to use correctly.

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

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

The input schema has 0% description coverage, so the description must compensate. It adds meaning for `schema_name` by documenting the special value 'all', but it does not explain `table_name` or clarify the interaction between the two parameters. The parenthetical '(table, index, columns)' hints at output fields rather than parameter semantics, providing only partial compensation.

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 indexes') and the resource ('indexes'), with the parenthetical '(table, index, columns)' specifying the returned fields. This distinguishes it from sibling tools like relationships_list_foreign_keys, which target foreign keys instead.

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, nor any exclusions or prerequisites. The only hint, `schema_name='all' for all schemas`, is a parameter behavior rather than tool-selection guidance, so the description lacks explicit usage context.

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

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

With no annotations provided, the description carries the burden of behavioral disclosure. It does reveal that this is a read operation ('Return') and specifies the exact content returned (USING and WITH CHECK code). However, it does not disclose error behavior (e.g., if policy not found), permission requirements, or side effects, leaving some ambiguity.

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

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

The description is a single, front-loaded sentence with no filler or redundant information. It efficiently states the tool's purpose and the key detail about the return content.

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

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

The tool is simple, but with no annotations and no parameter descriptions in the schema, the description leaves gaps: it does not explain why schema/table parameters are needed or what happens on error. The existence of an output schema reduces the need to describe return values, but the description still lacks important context for an agent to confidently invoke the tool.

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

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

The schema has three required parameters (schema_name, table_name, policy_name) with zero description coverage. The description only mentions 'by name', failing to explain that schema_name and table_name are needed to scope the policy. It does not add meaning beyond the bare parameter names, so it does not compensate for the lack of schema descriptions.

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

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

The description clearly states a specific verb ('Return') and resource ('definition ... of an RLS policy'), including the exact components (USING and WITH CHECK code). It distinguishes itself from sibling tools like rls_list_policies by specifying that it retrieves a single policy by name.

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

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

The phrase 'by name' implies the tool is for retrieving a specific policy rather than listing all, giving some usage context. However, it does not explicitly mention alternatives, when to use this versus other RLS tools, or any prerequisites or exclusions. The usage guidance is implied but not fully articulated.

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

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

No annotations are provided, so the description carries the burden. The word 'Report' implies a read-only operation, and the focus on coverage is clear. However, it does not disclose details like whether only tables with at least one RLS policy are included, or how policy counts are aggregated. It is minimally adequate but not rich.

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

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

The description is a single, front-loaded sentence (plus a compact parameter hint). Every word adds value, with no filler or repetition. It is appropriately sized for a 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, has one parameter, and an output schema exists, so the description need not explain return values. It clearly states the core behavior and the special schema_name value. It could mention that only tables with RLS enabled are included, but that is strongly implied by 'tables with RLS enabled'.

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

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

The input schema has only schema_name with a default but no description, and schema description coverage is 0%. The description adds essential meaning by explaining the special value 'all' to target all schemas. This compensates well for the missing schema documentation.

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

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

The description uses a specific verb ('Report') and resource ('tables with RLS enabled') and clearly states the output ('policy counts'). It distinguishes itself from siblings like rls_list_policies and rls_get_policy by focusing on table-level coverage rather than policy details.

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

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

The description provides no guidance on when to use this tool versus alternatives such as rls_list_policies or schema_list_tables. It includes a parameter tip (schema_name='all' for all), but this does not address tool selection or exclusions.

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

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

With no annotations provided, the description carries the full burden. It discloses that the tool returns a list with columns table, policy, command, and introduces the special value 'all' for schema_name, which adds behavioral context. However, it doesn't state potential side effects, permissions required, or error behavior. For a simple read-only listing tool, this is adequate but not rich.

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

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

The description is extremely concise, consisting of two short sentences. It is front-loaded with the primary action and provides a useful usage hint in the second sentence. Every word earns its place, with no redundancy or filler.

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

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

Given the simplicity of the tool (one optional parameter) and the presence of an output schema, the description is sufficient. It explains the core purpose and the special schema_name behavior. The description could be more explicit about the default schema behavior, but the schema's default value already covers that, so this is not a significant gap.

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

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

The input schema has no descriptions for parameters, but the tool description compensates by explaining the schema_name parameter and introducing the special value 'all' for all schemas. This adds meaning beyond the schema's default value of 'public', helping the agent understand how to use the parameter effectively.

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

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

The description clearly states the tool lists RLS policies and specifies the fields returned (table, policy, command). It distinguishes this from sibling tools like rls_get_policy by indicating a listing operation, though it doesn't explicitly name alternatives. The verb 'List' is specific and the resource 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 implies usage by stating schema_name='all' for all schemas, which tells the user how to get all policies. However, it doesn't explicitly explain when to use this tool vs alternatives like rls_get_policy or rls_list_coverage, nor does it mention the default behavior (e.g., defaulting to 'public' schema). Usage context is present but not fully explicit.

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

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

No annotations are provided, so the description must carry behavioral disclosure. It adds that table_name is optional and can restrict results, but it doesn't disclose the default schema behavior, error handling, or whether all schemas are considered. The phrase 'the schema' is ambiguous.

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

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

The entire description is a single clear sentence with no fluff. It is front-loaded with the action and resource.

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 with an output schema, but the description leaves gaps: it doesn't mention that omitting table_name returns all tables, nor does it explain schema_name. The ambiguity of 'the schema' further lowers 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 description coverage is 0%, so the description must compensate. It clarifies table_name as the optional filter ('restrict to one table'), but it never addresses schema_name or its default 'public'. Thus only half of the parameters are semantically explained.

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

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

The description uses a specific verb ('List') and resource ('columns for tables') that clearly distinguishes it from siblings like schema_list_tables and schema_list_views. The phrase 'in the schema' anchors the context.

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

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

The description implies when to use it: to get column information, optionally filtered to one table. It implicitly excludes views and enums by saying 'tables', and the 'Optionally restrict to one table' provides a conditional. However, no explicit 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?

No annotations provided, so the description carries the burden. It discloses the core behavior (listing enums) but does not mention any constraints, ordering, or whether system schemas are excluded. Adequate for a simple read-only listing, but limited.

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

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

Two short sentences with no redundant wording. The core purpose is front-loaded, and the usage tip is directly actionable.

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?

Simple tool with one optional parameter and an existing output schema. The description covers the key use cases and the important 'all' value, making it complete for the intended purpose.

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

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

Schema description coverage is 0%, but the description compensates by explaining the special 'all' value for the single parameter schema_name, which goes beyond the schema's type and default.

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 'List custom enum types' – a specific verb ('list') and resource ('custom enum types'). This distinguishes it from sibling tools like schema_list_tables, schema_list_columns, and schema_list_views.

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

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

Provides explicit usage guidance with 'Use schema_name='all' for all user schemas', which clarifies when to use the special value. Does not explicitly contrast with alternatives, but the tool's purpose is self-evident.

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

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

With no annotations, the description carries the burden of behavioral disclosure. It clearly indicates a read-only listing operation and adds the special 'all' behavior not evident from the schema. It does not mention caveats like system schemas, but for a simple listing tool this is sufficient transparency.

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

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

The description is two short, front-loaded sentences. Every word adds value: it states the action, the resource, the default, and the special case. No wasted words or redundant information.

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

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

The tool is simple with one optional parameter, and an output schema is present so return values are documented elsewhere. The description covers the essential behavior, default, and special value, making it complete for the tool's complexity.

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

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

The input schema has only one parameter with a default but no description. The description explains the parameter meaning ('schema to list tables from') and adds the key special value 'all' for all schemas, fully compensating for the 0% schema description coverage.

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

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

The description clearly states the tool lists tables in a given schema, using the specific verb 'list' and resource 'tables in the schema'. It also mentions the default schema and the special 'all' value, distinguishing it from sibling tools that list columns, views, or enums.

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

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

The description provides clear usage context by specifying the default schema and how to list all tables via schema_name='all'. However, it does not explicitly name alternative tools for other object types, though the sibling names make this obvious. Thus it has clear context but no explicit when-not-to-use guidance.

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

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

No annotations are provided, so the description carries the full burden of behavioral disclosure. It conveys that this is a listing/read operation and documents the special 'all' value behavior. However, it doesn't mention potential error conditions, case sensitivity, or whether system schemas are excluded, which are useful but not critical 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 two short sentences, front-loaded with the action ('List views') and immediately followed by the essential parameter guidance. Every word contributes value; there is no redundancy or filler.

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

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

For a single-parameter list tool with an output schema, the description sufficiently covers purpose, parameter semantics, and the special 'all' case. It does not discuss pagination or return format, but the output schema likely covers that. The main gap is the lack of explicit usage alternatives, but that's already partially addressed by sibling tool names.

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

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

With 0% schema description coverage, the description must compensate. It does so by explaining that `schema_name` identifies the schema to list views and that the special value 'all' covers all user schemas. This adds meaningful semantics beyond the schema's bare name and default value, though it stops short of detailing accepted formats or edge cases.

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

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

The description uses a specific verb ('List') and resource ('views') and ties it to the schema context, clearly differentiating it from sibling tools like schema_list_tables and schema_list_columns. The phrase 'in the given schema' immediately clarifies the primary parameter's role.

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

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

The description implies when to use the tool (when you need views in a schema) and gives a concrete usage tip for the `schema_name` parameter ('all' for all user schemas). It does not explicitly mention alternatives, but the sibling tool names and the resource-specific wording make the context clear.

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

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

With no annotations provided, the description carries the full burden. The verb 'List' implies a read-only operation, and the special schema_name='all' behavior is disclosed. However, it does not explain table_name behavior, output structure beyond column names, or any permissions or side effects.

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

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

The description is a single sentence with two clauses, front-loading the core purpose and adding a key usage hint. Every word contributes information, with no redundancy or filler.

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

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

For a simple listing tool, the description adequately conveys the purpose and one important behavior, but leaves a significant gap around table_name semantics and filtering logic. Since an output schema exists, return values need not be described, but parameter behavior is only partially covered.

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

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

Schema description coverage is 0%, so the description must compensate. It adds meaning only for schema_name via the 'all' special value, but leaves table_name entirely unexplained and does not clarify how the parameters interact. This is insufficient for a two-parameter tool.

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 ('List triggers') and enumerates the output columns (table, trigger, timing, event), making the tool's purpose clear. It is also distinct from sibling tools, which target other schema objects (tables, views, functions, etc.) rather than triggers.

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 listing triggers but does not explicitly state when to use this tool versus alternatives or exclusions. It provides a useful hint about schema_name='all' for all schemas, but this is more of a parameter tip than usage guidance.

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