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

Annotations already declare readOnly/idempotent/non-destructive, so safety is covered; the description goes well beyond by disclosing the return contents ('complete'/'partial'/'unavailable'), that it includes the missing permission and a GRANT in this server version's syntax, and the non-obvious SQL Server behavior of silent filtering. The write_access note adds a verification rationale not present in 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?

One dense paragraph that is front-loaded with what it reports, then when to call it. Every clause carries information, though the enumeration of return fields plus trigger list makes it heavier than strictly necessary for a 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?

There is no output schema, so the description must carry the return-value burden, and it does so thoroughly: visibility states, missing permission, version-specific GRANT, and write_access. Combined with the explicit trigger list, an agent has everything needed to call and interpret it.

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

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

Single parameter with 100% schema description coverage, so the schema already documents 'database'. The description adds no format or naming nuance beyond what the schema provides, which is the expected baseline when the schema does the heavy lifting.

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

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

States a specific verb and resource ('Reports what the connected login can and cannot see in a database') and enumerates exactly what it returns: identity, roles, effective permissions, server version, per-tool-group visibility states, and write_access. This is clearly distinguishable from the listing/definition siblings, which fetch schema objects rather than diagnose visibility.

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?

Gives explicit triggering conditions: a listing looks short, a definition comes back hidden, get_database_overview reports incomplete visibility, or a tool fails with a permission error. It even names a sibling (get_database_overview) as the signal source and explains the failure mode ('SQL Server leaves out what a login cannot see without raising any error'), so the agent knows when to reach for this instead of assuming missing data.

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 already declare readOnly, idempotent and non-destructive, so safety is covered; the description adds real behavioral context by scoping the comparison to tables and columns and by disclosing that differences carry a type_declaration rendered as 'nvarchar(250) vs nvarchar(50)'. It does not describe pagination, output size, or how large diffs are presented, keeping it short of a 5.

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 core action and its diff categories are front-loaded, then usage, then scope exclusions and the alternative. Dense but every clause carries information, including the illustrative type_declaration example.

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

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

With no output schema, the description compensates by explaining exactly what the result contains (one-sided tables, one-sided columns, type/nullability mismatches with type_declaration). Combined with the explicit scope boundary and the handoff to get_table_schema, an agent has everything needed to call it correctly.

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

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

Schema description coverage is 100%, with source/target_database and the empty-means-every-schema filters fully documented in the schema, so the baseline is 3. The description mentions 'two configured databases' but adds no format or constraint detail beyond what the schema already provides.

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

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

Names a specific verb (compares) and resource (table and column structure of two configured databases) and enumerates the exact diff categories it produces. An agent can distinguish it from siblings like get_table_schema or get_schema_summary without opening a schema.

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?

States when to use it ('check a migration or detect drift'), what it explicitly does not cover ('tables and columns only, not views, code, indexes or data'), and routes the agent to a named alternative ('to see one differing table in full, call get_table_schema on each database'). This is explicit when/when-not/alternative guidance.

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

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

Annotations already declare readOnlyHint=true, idempotentHint=true, destructiveHint=false and a closed-world scope, so safety is covered. The description still adds behavioral value by disclosing the default inclusion of views and the content of each result (type_declaration and nullability).

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 tight clauses: the capability first, then the routing guidance. No filler, and the scope constraint (tables plus default views) is front-loaded.

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

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

With no output schema present, the description compensates by naming the returned fields (type_declaration, nullability) and the default view behavior. Combined with the fully documented input schema and safety annotations, an agent has everything needed to call it correctly.

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

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

Schema description coverage is 100%, so the schema already documents all four parameters in detail, including the unanchored pattern semantics and the schema default. The description only echoes the view default and adds no parameter detail beyond the schema — the expected baseline of 3.

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

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

States a specific verb and resource: finds every table and (by default) every view holding a column matching a name pattern. It also names the sibling tools (list_tables, list_views) that find objects by their own name, so an agent can discriminate without opening a schema.

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?

Gives explicit scenarios — before a rename, a widening, or an impact review — and explicitly routes the alternative case ('to find objects by their own name') to list_tables or list_views. When and when-not are both covered.

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 already declare readOnly/idempotent/non-destructive, but the description adds real context beyond them: the return payload structure ('dot', 'nodes' with node_kind, 'edges' with dependency_kind) and a permission caveat via 'visibility'. The caveat that references from code can be missing for lack of permission is valuable behavioral disclosure that annotations do not carry.

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

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

Three sentences, front-loaded with purpose and edge semantics, then output shape, then alternatives and caveats. Dense but nearly every clause earns its place; the mention of 'visibility' without saying whether it is an input or output field adds slight ambiguity.

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

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

No output schema exists, so the description carries the return-value burden and does so by naming the 'dot', 'nodes' and 'edges' fields. Combined with alternatives, the schema-filter caveat and the permission caveat, an agent has everything needed to call and interpret 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?

Schema description coverage is 100%, so the baseline is 3; the description goes further by explaining the practical consequence of the schema filter ('a whole database makes an unreadable diagram, so narrow it with schema'), which gives the agent a reason to set it rather than just its 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?

States a specific verb and resource ('Generates a Graphviz DOT diagram of the dependencies between database objects') and immediately clarifies the edge semantics (arrow from each object to what it depends on, via FK or code reference). It is clearly distinguishable from the sibling get_dependency_graph, which returns edges only.

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

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

Explicitly routes the agent: use this to draw the graph, use get_dependency_graph for edges alone, and get_table_usage for references to a single table. It also warns that a whole-database diagram is unreadable and instructs narrowing with schema, which is actionable when-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?

Annotations already declare readOnly/idempotent/non-destructive, and the description goes well beyond them: counts are scoped to what the login can see, the 'visibility.complete' flag is explained as false when SQL Server hides objects, and check_permissions is named as the follow-up for missing GRANTs. This is real behavioral disclosure an agent cannot get from the schema.

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

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

Three tight sentences, front-loaded with what is returned, then usage, then a caveat about visibility. Every clause carries information; nothing is redundant with the name or title.

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

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

With no output schema, the description compensates by enumerating the returned figures and even naming the 'visibility.complete' field, and it explains the degraded-visibility case plus the remediation path. Nothing needed to call or interpret this tool is missing.

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

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

Schema coverage is 100% and the single parameter is fully documented as 'Name of the database as registered in the configuration.' The description doesn't add format or lookup detail for the parameter itself, so the baseline of 3 applies — the schema does the heavy lifting.

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

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

Specific verb ('Summarizes one database') plus an explicit enumeration of what the summary contains (real name, server/instance, login, object counts, allocated MB). This is clearly distinguishable from siblings like get_schema_summary and list_databases.

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?

States the workflow position explicitly ('after list_databases to size up a database before exploring it') and names the alternative for a different granularity ('for the same figures per schema use get_schema_summary'). When-to-use and the sibling selector are both spelled out.

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 already establish that this is a safe, idempotent, non-destructive read, so the description needn't restate safety. It does add genuinely useful behavioral context beyond the annotations: it 'reads actual row values and scans the table', so on a large table 'it can take a while'. That performance warning is the kind of thing an agent needs and annotations cannot convey.

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 dense sentences with zero filler: the first defines what it returns, the second covers usage and cost. Nothing is buried and nothing is repeated from the schema.

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

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

With no output schema, the description compensates by naming the exact metrics returned per column, and it flags the cost profile of the operation. For a read-only profiling tool of this complexity, an agent has everything needed to call it correctly.

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

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

Schema description coverage is 100%, so all five parameters are already documented, including the comma-separated column format and the top_values default. The description only echoes the columns-scoping idea ('limit it to the columns you need') without adding syntax or format detail. 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?

States a specific verb (profiles) and resource (columns of one table or view), then enumerates the exact metrics returned: null ratio, distinct count, min, max, most frequent values. This is unmistakable against siblings like query_table or get_table_schema.

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

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

Explicitly routes the agent away from the alternative: 'without paging through rows with query_table', and adds the scoping advice 'limit it to the columns you need'. Both when-to-use and a practical constraint are 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?

Annotations already declare readOnly/idempotent/non-destructive, but the description adds substantive operational context: it fails with an explicit message when the login lacks read access to sys.sql_expression_dependencies, and it warns that without VIEW DEFINITION the module edges only cover readable modules — i.e. results can be silently partial. That is exactly the beyond-annotation disclosure this dimension rewards.

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 tight sentences, each carrying distinct load: what it returns, when to use it vs alternatives, then failure and permission caveats. Nothing is redundant and the purpose is front-loaded.

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

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

No output schema exists, so the description must describe the return — and it does, specifying that the result is edge data with concrete edge categories. Combined with the failure/permission caveats, an agent has everything needed to call it and interpret partial 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%, so both parameters (schema filter, database name) are already documented in the schema, and the description adds no syntax or format detail beyond that. Baseline 3 is correct when the schema carries the parameter burden.

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?

States a specific verb and resource ('returns the dependency edges between database objects as data') and enumerates the covered edge types (foreign keys, view/procedure/function references). It explicitly distinguishes itself from siblings generate_dependency_dot and get_table_usage, so an agent can route without opening a schema.

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

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

Explicitly says to use it 'to analyze dependencies programmatically' and names the two alternatives with the conditions that select them: a diagram via generate_dependency_dot, and single-table references via get_table_usage. When/when-not is fully covered.

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 already declare readOnly/idempotent/non-destructive, and the description adds substantive behavior beyond them: the server never executes functions, and unreadable-but-visible functions return definition null with definition_visible false. That permission-driven return behavior is exactly the kind of trait an agent could not infer from the schema.

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

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

Three tight sentences, zero filler, with the core purpose front-loaded and the permission caveat and non-execution guarantee following logically. Every sentence earns its place.

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

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

No output schema exists, and the description compensates by explaining the returned payload (CREATE FUNCTION text) and the null/false outcome for restricted functions. With a well-documented 3-param schema and covered safety annotations, nothing an agent needs is missing.

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

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

Schema description coverage is 100% (schema, database, function all documented with examples and defaults), so the schema carries parameter meaning. The description adds nothing further about parameter format or the empty-schema wildcard behavior, so the baseline 3 applies.

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

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

Specific verb and resource: 'Returns the CREATE FUNCTION text of one user-defined function.' It clearly differentiates itself from siblings like get_procedure_definition and get_view_definition by naming the exact object type and payload.

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?

Names the workflow it belongs to ('use it to read or review a function found with list_functions') and clarifies the server never executes functions, giving clear context for selection. It stops short of stating explicit when-not-to-use conditions or naming a directly competing sibling.

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?

Goes well beyond the readOnly/idempotent annotations to disclose that unused and missing-index data comes from server DMVs, that these reset on SQL Server restart, that without VIEW SERVER STATE the values come back null, and that 'visibility.unavailable' explains why while duplicates are still reported. This is exactly the kind of operational caveat an agent needs to interpret results correctly.

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

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

Three tightly packed sentences: purpose/outputs first, routing guidance second, data caveats third. No filler, and the key scoping information is front-loaded. It is dense but every clause 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?

With no output schema, the description carries the return-value burden and does so by naming the three result categories and explaining the null/'visibility.unavailable' failure mode. Combined with the sibling routing and permission caveat, an agent has everything needed to call and interpret 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?

Schema description coverage is 100%, so both parameters (schema filter, database) are already documented in the input schema, including the empty-string default and an example. The description reinforces the by-schema scoping but adds no syntax or format detail beyond the schema, so baseline 3 applies.

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

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

States a specific verb (Reports) and resource (index health) and enumerates the three output categories: duplicate index candidates, unused indexes, and missing-index suggestions. It also names the sibling it is not (get_table_schema for a single table), so an agent can distinguish it without opening schemas.

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

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

Explicitly says when to use it ('when reviewing indexing or slow queries') and routes the agent to an alternative for a narrower case ('for one table's indexes use get_table_schema'). Both the selection condition and the exclusion are stated, leaving nothing to inference.

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 already establish readOnly/idempotent/non-destructive, so the safety profile is covered. The description adds genuinely useful behavior beyond that: it never executes procedures, and a procedure the login can see but not read returns definition null with definition_visible false — a non-obvious permission edge case.

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

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

Three sentences, each earning its place: what it returns, when to use it, and the permission edge case. Front-loaded with the core purpose with zero 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?

No output schema exists, so the description carries the return-value burden and does so: it names the payload (CREATE PROCEDURE text) and the null/definition_visible failure shape. Combined with full param coverage and annotations, an agent has everything needed to call and interpret it.

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

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

Schema description coverage is 100%, so the schema already documents schema, database, and procedure semantics including wildcard behavior for empty schema. The description adds no parameter-level detail beyond that, so the baseline 3 applies.

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

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

States a specific verb and resource ('Returns the CREATE PROCEDURE text of one stored procedure'), scoping it to a single procedure and distinguishing it from the listing siblings. An agent can tell instantly that this reads source text, not metadata or execution results.

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

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

Explicitly routes the agent: use it to read or review a procedure found with list_procedures, and clarifies that this server never executes procedures. Clear context, though it does not name alternatives such as get_function_definition or state 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?

Annotations already declare readOnlyHint, idempotentHint, non-destructive, and closed-world, so the safety profile is fully covered. The description adds useful content-level detail about what the summary contains (row estimates, index/data size), which matters since there is no output schema, but it says nothing about cost, limits, or behavior on unregistered/large databases. With annotations carrying the safety burden, a 3 is appropriate.

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

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

Two sentences, zero filler: the first delivers the payload contents, the second front-loads the routing decision before naming alternatives. Every clause 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 read-only aggregate tool with no output schema, the description supplies the return contents, the intended planning use case, and disambiguation from the two nearest siblings. Nothing an agent needs in order to call it correctly is missing.

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

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

Schema coverage is 100%: both parameters are documented in the schema, including the empty-string default meaning 'every schema' and an example value. The description adds no parameter-level syntax or filtering semantics beyond what the schema already provides, so the baseline 3 applies.

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

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

States a specific verb (summarizes) and resource (each schema of a database) and enumerates exactly what is produced: table/view/procedure/function counts, approximate rows, and estimated data/index size. It explicitly distinguishes itself from get_database_overview and list_tables, so an agent can place it among 20 siblings without opening the schema.

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?

Gives an explicit use case ('before exploring or planning a refactoring') and names two alternatives with the conditions that select them: whole-database totals -> get_database_overview, tables of one schema -> list_tables. Nothing is left to inference.

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 already declare readOnly, idempotent, and non-destructive behavior, so the safety profile is covered. The description adds real interpretive value beyond that — the warning that max_length is a raw sys.columns BYTES value and that type_declaration/max_length_chars should be used instead — which prevents a common agent error.

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?

Front-loaded with the core statement of what is returned, followed by a dense enumeration of return contents and a usage/caveat sentence. It is long but information-dense; the enumerated return fields are justified because no output schema exists.

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

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

With no output schema, the description carries the burden of describing return values and does so thoroughly, listing every included element plus key interpretation caveats. An agent has everything needed to call and interpret this tool correctly.

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

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

Schema coverage is 100%, so the schema already documents table, schema, and database parameters including the bare-name format and empty-schema-wildcard behavior. The description adds nothing parameter-specific beyond the notion of one table or view, so the baseline of 3 applies.

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

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

States a specific verb+resource (returns the full structure of a table or view) and enumerates exactly what is included: columns, type declarations, extended properties, computed columns, keys, constraints, and indexes. It is clearly distinguishable from siblings like get_view_definition or list_tables.

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

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

Explicitly tells the agent when to call it ('before query_table to learn exact column names and types') and names the alternative for a related need ('for a view's SQL text use get_view_definition'). The routing decision is unambiguous.

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

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

Annotations already cover readOnly/idempotent/non-destructive, so the bar is lower, and the description adds real operational context: sql_module_usage is null when the login cannot read dependencies, and 'visibility' flags when the list may be incomplete. This permission-dependent degradation is genuinely useful and not derivable from the annotations, though it does not cover rate limits or pagination.

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 tight sentences, front-loaded with the core behavior and followed by routing and caveats. No filler; every clause carries 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?

No output schema exists, so the description compensates by naming the returned fields that matter (sql_module_usage, visibility) and explaining their edge cases. Combined with full schema coverage and safety annotations, an agent has everything needed to call and interpret it.

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

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

Schema description coverage is 100%, so all three parameters (table, schema, database) are already documented in the schema, including the empty-schema-means-all-schemas behavior and the bare-name constraint. The description adds no further parameter meaning, so the baseline 3 applies.

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

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

States a specific verb and resource ('Lists everything that references one table') and enumerates the exact reference kinds returned: foreign keys in/out plus views, procedures and functions using it. It explicitly differentiates itself from the sibling get_dependency_graph, so an agent can distinguish the two without opening schemas.

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?

Gives an explicit use case ('impact analysis before changing a table') and names the alternative for the other case ('for the dependency graph of the whole database use get_dependency_graph'). Both the when-to-use and the when-to-use-something-else are 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?

Annotations cover safety (readOnly, idempotent, non-destructive), so the bar is lower, and the description adds genuinely useful behavior beyond annotations: the null-definition/definition_visible=false case for unreadable views and the pointer to check_permissions. It does not cover existence errors or output shape details, but the access-edge behavior is a substantive addition.

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

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

Three sentences, front-loaded with the return value, then usage, then the edge case. No filler or repetition.

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 read-only tool with exhaustive annotations, full schema coverage, and no output schema needed for an access-edge case, the description covers purpose, sibling routing, upstream-navigation pointer, and the permission edge case. Nothing an agent needs to call it correctly is missing.

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

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

Schema description coverage is 100%, so the schema documents the parameters (view, schema, database) including formats and defaults. The description adds nothing parameter-specific, so baseline 3 applies.

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

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

States a precise verb+resource: returns the CREATE VIEW text plus columns. It explicitly positions itself against get_table_schema (same detail level) and get_dependency_graph (for source objects), which are the natural alternatives in this sibling set.

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?

Clear context for use: see how a view derives data, and a routing hint to get_dependency_graph for upstream objects. It does not state exclusions (e.g., that it errors if the view does not exist) nor explicitly contrast with list_views, but the intended usage context is well established.

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?

Beyond the readOnly/idempotent annotations, the description discloses that it reads only server configuration and never connects to SQL Server, plus the exact failure shape when nothing is configured (ok: false with file to create, search locations, and an example). These operational details are not available in the annotations and materially affect how an agent handles the result.

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

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

Three sentences, each load-bearing: what is returned, why to call it first, and what the failure path looks like. The most important guidance ('Call it first') is front-loaded after the purpose statement.

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

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

With no output schema, the description fully describes the returned payload (names plus row limit and timeout per entry) and the error payload shape. Nothing an agent needs to call this zero-parameter tool correctly is missing.

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

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

Zero parameters, so the baseline of 4 applies. The description does explain the downstream convention that the returned names are consumed as a 'database' argument by other tools, which adds a little semantic value, but there is no parameter syntax to clarify.

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

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

States a specific verb and resource ('Lists the logical database names this server is configured to reach') and further narrows scope by naming what each entry contains (row limit, command timeout). An agent can distinguish it from siblings like get_database_overview or list_schemas immediately.

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

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

Explicitly instructs 'Call it first' and explains why: every other tool, starting with get_database_overview, requires one of these names as its 'database' argument. The ordering dependency and the downstream consumer are both named, leaving no inference to the agent.

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 cover safety (readOnly, idempotent, non-destructive), so the bar is lower. The description adds genuinely useful non-obvious behavior: SQL Server silently omits functions the login lacks permission on without error, and it points to get_database_overview/check_permissions for diagnosing that. Doesn't mention return format, but that's acceptable.

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 tight sentences, front-loaded with the core purpose, then routing, then the non-obvious permission caveat. Every sentence earns its place.

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

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

For a 2-param read-only list tool whose safety profile is covered by annotations, the description covers purpose, scope, routing, and the silent-permission-omission edge case that would otherwise cause confusing empty results. Nothing an agent needs is missing.

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

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

Schema description coverage is 100%, so the schema fully documents both parameters (schema filter with example, database name). The description adds no parameter-level syntax beyond what the schema 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?

States a specific verb and resource ('Lists the user-defined functions'), and precisely enumerates scope (scalar, inline TVF, multi-statement TVF), distinguishing it from siblings like list_procedures and get_function_definition.

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

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

Explicitly says 'Use it to find functions; for one function's text use get_function_definition' – names both the use case and the alternative tool with the condition that selects 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?

Annotations already declare readOnly/idempotent/non-destructive, but the description adds substantial behavior beyond them: definition_visible=false and null metrics when text is hidden, referenced_object_count null when dependencies are unreadable, and SQL Server's silent omission of unauthorized procedures.

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?

Front-loaded with the core purpose and routing, then the caveats. Dense but every sentence carries information; the caveat sentence is long and could be split, but nothing is wasted.

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

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

Despite no output schema, the description explains the returned complexity metrics and their null semantics, and covers the edge case of silently omitted procedures plus where to diagnose it. Nothing an agent needs to call or interpret this tool is missing.

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

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

Schema description coverage is 100%, so both parameters (database, schema filter with default and example) are already fully documented in the schema. The description adds no parameter-level syntax or format detail, so the baseline of 3 applies.

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

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

States a specific verb and resource ('Lists the user stored procedures') plus scope ('the login can see') and the extra data returned. It is clearly separable from the sibling get_procedure_definition, which it names.

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

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

Explicitly says when to use it ('find procedures and pick the complex ones') and names the alternative for the other case ('for one procedure's text use get_procedure_definition'). It further routes the agent to get_database_overview and check_permissions for the silent-permission-omission situation.

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 already declare readOnly, idempotent, non-destructive and closed-world, so the safety profile is covered. The description adds real behavioral context beyond that: system schemas are excluded and owners are included in the output.

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

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

Two sentences, zero waste, with the scope constraint front-loaded and the routing guidance relegated to the second sentence. Every clause earns its place.

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

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

For a one-parameter read-only list tool with full annotation coverage and no output schema, nothing an agent needs to invoke it correctly is missing; scope, exclusions, and sibling routing are all present.

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

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

There is a single parameter with 100% schema description coverage ('Name of the database as registered in the configuration'). The description references the database implicitly but adds no syntax or format detail beyond the schema, so baseline 3 applies.

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

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

States a specific verb (lists), resource (user schemas of a database), and scope (with owners, excluding system schemas). It is clearly distinguishable from the sibling get_schema_summary, which it explicitly names.

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

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

Gives an explicit use case ('learn the names the schema filter of the other tools accepts') and names the alternative tool with the condition that selects it (object counts and sizes per schema). No inference required.

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 already declare the safety profile (readOnly, idempotent, non-destructive, closed-world), so the bar is lower. The description adds value by disclosing what is returned, notably that row counts are approximate and sizes are in MB, which an agent cannot infer from structured fields alone. It stops short of covering pagination or result-limit behavior on large databases.

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 tight sentences: the first front-loads what the tool returns, the second covers routing and narrowing. No filler, and the most load-bearing information (scope plus alternatives) leads.

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

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

With no output schema, the description carries the burden of describing return values and does so field by field. Combined with the sibling routing and parameter narrowing advice, an agent has everything needed to select and invoke this tool correctly.

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

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

Schema description coverage is 100%, including the non-obvious semantics of name_pattern (substring match without %, add % for prefix/suffix). The description only echoes 'narrow with schema and name_pattern' and adds no syntax beyond the schema, so the 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?

Opens with a specific verb and resource ('Lists user tables') and enumerates the exact return fields (schema, approximate row count, data/index size in MB, creation/modification dates). It also explicitly distinguishes itself from find_columns and get_table_schema, so an agent can disambiguate without opening a schema.

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?

Gives concrete when-to-use cases ('find tables by name or schema', 'spot the large ones') and routes to alternatives by naming both find_columns (column-based lookup) and get_table_schema (single-table details) with their selecting conditions. The closing hint about narrowing with schema and name_pattern is actionable 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?

Annotations already declare readOnlyHint, idempotentHint, openWorldHint=false, and destructiveHint=false, so the safety profile is fully covered elsewhere. The description adds the operational hint that schema and name_pattern narrow large databases, plus a hint that the result includes each view's schema, but says nothing about pagination or the full return shape. Useful context on top of annotations, but not rich.

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

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

Two tight sentences with zero filler: the purpose and output scope come first, then the alternatives, then the filtering advice. Every clause 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 three-parameter read-only list tool with annotations covering safety and a fully documented schema, the description supplies purpose, alternatives, and narrowing guidance. The only omission is any mention of result limits or pagination, which is minor here.

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

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

Schema description coverage is 100%, so the schema already documents all three parameters including pattern semantics and defaults, making 3 the baseline. The description reinforces how schema/name_pattern are used for narrowing large databases but adds no syntax or meaning beyond what the schema states.

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?

States a specific verb and resource ('Lists user views with their schema') and explicitly distinguishes itself from the sibling tools that return view details (get_view_definition) and tables (list_tables). An agent can route correctly without opening any schema.

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

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

Explicitly gives the when ('find views by name or schema') and names two alternatives with the condition that selects each: get_view_definition for columns/SQL text, list_tables for tables. Nothing is left to inference.

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?

Beyond the readOnly/idempotent annotations, it discloses the return shape (row_count plus a measured 'truncated' flag), that rows are capped by the database's max_query_rows, and that it never runs INSERT/UPDATE/DELETE or procedures. The truncation semantics are exactly the kind of behavior that prevents misreading a short result.

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?

Front-loaded with the operation and its capabilities, then the output contract, then the sibling routing, then the read-only boundary. Dense but every clause earns its place; the single long sentence is slightly overloaded but stays scannable.

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 an 11-parameter query tool with no output schema, the description compensates by describing the returned object (rows, row_count, truncated) and the row cap. An agent has everything needed to call it and interpret results correctly.

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

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

Schema coverage is 100% and each of the 11 parameters is documented with examples, so the description need not carry parameter detail. It only summarizes the parameter surface (filters, grouping, aggregates, sampling) without adding syntax or format beyond the schema, which is the expected 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?

Names a specific verb (SELECT) and resource (one table or view) and enumerates the supported clauses: column list, filter, ordering, grouping, aggregates, pagination, sampling. An agent can distinguish this from sibling readers like get_table_schema or get_data_profile without opening schemas.

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

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

Explicitly routes the agent: call get_table_schema first for exact column names, and use get_data_profile for null ratios, distinct counts and frequent values instead of paging through rows. Both a prerequisite and a when-not alternative are stated.

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