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

With no annotations, the description carries full responsibility for disclosing behavior. It says the tool connects a session and lists supported engines, but it does not mention side effects, connection persistence, authentication requirements, or implications of the allow_write parameter. An agent is left without a clear picture of what 'connect' changes in the system.

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. It is concise and communicates the core action and engine options immediately, though the brevity leaves out important context that is penalized in other dimensions.

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

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

For a tool with four parameters, no annotations, and an output schema not shown, the description is too sparse. It fails to explain format expectations for 'url', the meaning of 'allow_write', or what happens upon successful connection. An agent cannot confidently invoke this tool correctly based solely on the description.

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

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

Schema description coverage is 0%, so the description must compensate. It does add meaning for 'engine' by enumerating supported values and hints at 'session_name' with 'named session', but it says nothing about the critical 'url' parameter or the 'allow_write' flag. The compensation is partial at best.

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 ('Connect') and the resource ('a named session'), and the engine list adds specificity about supported database types. However, it does not explicitly differentiate itself from siblings like db_status or db_disconnect, relying on the 'connect' verb to imply its 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?

There is no guidance on when to use this tool versus alternatives such as db_status or db_query, nor any mention of prerequisites like requiring a server to be reachable. The description only states what the tool does, not when or when not to invoke it.

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

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

With no annotations, the description carries the full burden of behavioral disclosure. It does flag that deletion only happens when confirm=true, which is an important safeguard beyond the schema's default. However, it does not mention irreversibility, cascade behavior, transaction effects, or what happens if where_sql is empty, so the disclosure is only partially complete.

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: two short sentences. The core behavior is front-loaded, and the critical safety requirement is stated immediately after. No filler or redundancy 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?

For a destructive tool with six parameters and zero schema descriptions, the description omits crucial context: the table parameter is not mentioned, params_json and session_name are unexplained, and there is no warning about empty where_sql. The output schema covers return values, so that part is not needed, but the overall guidance is too thin for safe and correct use.

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

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

The schema has 0% description coverage, so the description must compensate. It adds some meaning for where_sql and confirm, but table, schema, params_json, and session_name remain unexplained. Given the large number of undocumented parameters, this is insufficient for reliable invocation.

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 and target: 'Delete rows matching where_sql' – a specific verb with a clear resource. It does not explicitly name sibling tools like db_execute or db_update, so it doesn't fully differentiate itself, but the delete-vs-query/update/insert distinction is evident from the wording.

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 db_delete versus alternatives such as db_execute, db_update, or db_query. The only usage note, 'confirm=true is required,' is a safety precondition, not a use-case justification. An agent gets no help deciding between this and sibling database tools.

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

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

The verb 'describe' signals a read-only introspection, which is a useful behavioral cue. However, with no annotations provided, the description carries the full burden and does not disclose whether an active session is required, how session_name affects the operation, or what errors may occur.

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. It clearly communicates the core action and object without wasting words.

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

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

An output schema exists, so return-value details are not required in the description. However, the description is incomplete for correct invocation: it omits the need for an active database session, the meaning of session_name, and how schema interacts with the table parameter.

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

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

Schema description coverage is 0%, so the description must compensate, but it does not explain any of the parameters. In particular, session_name and schema are non-obvious: session_name selects a connection/session, and schema qualifies the table, but neither is mentioned.

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

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

The description states a clear verb and resource: 'Describe columns of a SQL table.' This distinguishes it from sibling tools like db_list_tables, though it could more explicitly say it targets the current session or 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?

No guidance is given about when to use this tool versus alternatives, nor does it mention prerequisites such as an active connection or session. The sibling list includes db_connect, db_list_tables, and db_query, but the description does not reference any of them.

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

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

With no annotations, the description must disclose behavioral traits, but it only states the operation without revealing side effects (e.g., closing connections, rolling back transactions, error behavior). It is dangerously under-specified for a state-changing operation.

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

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

The description is extremely concise (one sentence) and front-loaded with the purpose, but it is too sparse to be considered efficient; it sacrifices essential detail for brevity.

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

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

For a tool with one optional parameter and no annotations, the description is inadequate. It does not explain the return value (despite an output schema being present), side effects, or when it should be invoked, leaving an agent under-informed.

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

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

The schema has one parameter (session_name) with a default, but the description makes no mention of it. Schema description coverage is 0%, so the description fails to compensate for the missing documentation, leaving the agent without guidance on how to use the parameter.

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

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

The description clearly states the action 'Disconnect' and the resource 'database session', which is specific and distinguishes it from sibling tools like db_connect or db_status. The verb-resource pairing is 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 alternatives (e.g., db_status to check session state) or any prerequisites. The description does not explain when disconnecting is appropriate or what happens if no session exists.

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

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

No annotations are provided, so the description carries the full behavioral burden. It does disclose one important behavior: DROP, TRUNCATE, and ALTER require confirm=true. But it does not say what happens when confirm is missing, whether the statement is auto-committed, or what side effects occur beyond the write itself.

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 filler. The core action is front-loaded and the confirm requirement is a necessary, high-value warning placed right after the main description.

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

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

For a tool with four parameters, zero schema descriptions, and no annotations, the description is too thin. It leaves params_json and session_name unexplained and does not describe error behavior or the meaning of the returned output, though an output schema does exist.

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

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

Schema description coverage is 0%, so the description must compensate for four undocumented parameters. It only adds meaning to confirm by specifying which operations need it; sql, params_json, and session_name receive no semantic explanation in the description.

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

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

The description clearly identifies the tool as executing a write statement, which separates it from read-oriented siblings like db_query. The DROP/TRUNCATE/ALTER examples hint at broader SQL support, but it does not explicitly distinguish itself from db_insert, db_update, or db_delete, so the boundary is not fully crisp.

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 'Run a write statement' implies this is the tool for write operations, and the confirm requirement suggests it handles destructive DDL. However, there is no explicit guidance about when to use db_execute versus the more specialized db_insert/db_update/db_delete tools, and no exclusions 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?

With no annotations, the description must fully disclose behavior. It does not mention that the operation is a write, any transactional semantics, whether existing data is preserved, or error behavior. The short description leaves significant behavioral gaps.

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

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

The description is extremely short and to the point, front-loading the core action. However, it sacrifices necessary details for brevity, making it borderline under-specification rather than ideal conciseness.

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 having an output schema, the description omits essential context: no mention of required connection, no example of values_json format, no handling of schemas, and no notes on how to construct a valid insert. An agent would need to inspect the schema and possibly the output schema to infer usage.

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

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

Schema coverage is 0%, so the description must compensate for undocumented parameters. It only explains values_json, but leaves table, schema, and session_name without any added meaning. This is insufficient for a 4-parameter tool with zero 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 states the verb 'insert' and resource 'row', but does not specify the target table or clarify how columns are mapped. It is distinguishable from other db tools in name, but the description is minimal.

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

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

No guidance on when to use this tool versus db_execute or db_update, nor mention of any preconditions like needing a connection. Sibling tools imply context, but description fails to clarify boundaries.

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

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

With no annotations, the description carries the behavioral burden. 'List' conveys a read-only operation, and the Oracle/Postgres note adds schema-behavior context. However, it does not disclose prerequisites like an active SQL session, whether the operation can fail if no session exists, or what schema is used when the schema parameter is empty.

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 compact sentences with no filler. The primary action is front-loaded, and the second sentence provides relevant cross-database context that helps an agent choose the correct schema value.

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

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

The definition is adequate for a straightforward listing tool and benefits from the output schema. However, it omits guidance on session_name, connection prerequisites, and what happens when schema defaults to an empty string, so an agent may not fully know how to invoke it correctly in all situations.

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 useful meaning to the schema parameter by explaining the difference between Oracle schema-as-owner and Postgres public schema. Yet it says nothing about session_name or the behavior of default values, leaving part of the parameter surface unexplained.

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 action ('List tables') and a clear resource ('tables in a SQL schema'), which distinguishes it from non-SQL sibling tools like mongo_list_collections and redis_keys. The Oracle/Postgres schema nuance further clarifies what is being enumerated.

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: for listing tables in a SQL schema, especially with Oracle or Postgres session contexts. However, it does not explicitly contrast this with alternatives such as db_describe_table for schema details or db_query for data access, so the usage guidance is mostly implicit.

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 disclosure burden. It does clarify that the operation is read-only and that results are capped at a maximum of 500, which are useful behavioral details. It does not mention prerequisites such as an active session or behavior on invalid binds/limits, so the behavioral picture is incomplete.

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 three short sentences with no filler: purpose, bind syntax, and result cap are each covered once and front-loaded. Every clause earns its place, and nothing needs to be removed.

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 has four parameters and no annotations, and the description covers sql, params_json, and limit but is silent on session_name and the need for an established connection/session. The presence of an output schema means return values do not need elaboration, but the missing invocation prerequisite keeps this from being complete.

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

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

Schema description coverage is 0%, so the description must compensate, and it does for most parameters: sql is described as a read statement, params_json is explained as holding :name named binds, and limit is documented as a result cap. session_name is left entirely unexplained, which prevents a perfect score.

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

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

The description states a clear action — 'Run a read statement' — which identifies the tool as a read-only query operation and distinguishes it from the write-oriented siblings like db_execute, db_insert, db_update, and db_delete. It does not explicitly name an alternative, but the read/write contrast gives an agent enough signal to pick it correctly.

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 'read statement' implies this is for SELECT-style queries, so an agent can infer when to use it among mutation siblings. However, it never explicitly states when not to use it or points to db_execute for non-read statements, so the guidance is implied rather than prescriptive.

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

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

No annotations are provided, so the description carries the burden of behavioral disclosure. The verb 'List' implies a read-only status operation, and the description states the output scope (sessions and engines), but it does not explicitly state side effects, permission requirements, or whether an active connection is needed.

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

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

A single, front-loaded sentence with no filler. Every word adds meaning: 'List' signals the operation, and 'active database sessions and supported engines' defines the scope.

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

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

For a zero-parameter status tool with an output schema present, the description is sufficient. It tells the agent exactly what information the call exposes, and there are no input requirements to document.

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

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

The tool has zero parameters, so there is nothing for the description to explain. The schema is empty and the description correctly focuses on what the tool returns rather than input semantics.

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

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

The description names a specific verb and resource: 'List active database sessions and supported engines.' It clearly identifies what the tool returns and is distinguishable from siblings like db_connect, db_query, or redis_get, none of which cover status/engine information.

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

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

The description gives no guidance on when to use this tool versus alternatives. It does not mention whether it should be called before db_connect, whether it requires an existing session, or when a sibling like db_list_tables would be more appropriate.

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

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

No annotations are provided, so the description carries the full burden of behavioral disclosure. It does state that where_sql is required and gives an example, which is a constraint, but it does not disclose what happens on update (e.g., affected rows, errors, side effects) or whether it is destructive. It also lacks information on permissions or session requirements.

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 sentence and front-loaded with the core action, so it is concise. However, it is under-specified, providing minimal information beyond the action. It is not verbose, but it does not earn its place by conveying essential details; it reads as a stub.

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

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

Given the complexity (6 parameters, 3 required) and zero schema descriptions, the description is severely incomplete. It omits explanations for values_json, params_json, session_name, and schema, and does not describe return values or behavior. An agent would be unable to construct a valid call without additional documentation.

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 only explains where_sql with an example, leaving the other five parameters (including the required values_json) completely unexplained. This is a major gap for a tool with six parameters.

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

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

The description clearly states the action 'Update rows' with a specific verb and resource. It also gives an example of the where_sql format, making the core purpose understandable. However, it does not differentiate from sibling tools like db_insert or db_execute, though the verb is distinct enough within the db_* family.

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 like db_execute or db_query. The description only implies it is for updating rows but does not mention prerequisites (e.g., being connected), nor does it provide exclusions or alternative selection criteria.

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

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

With no annotations, the description carries the full burden. It correctly signals destructive behavior and the mandatory confirmation flag, which is useful. However, it does not mention irreversibility, behavior when the document does not exist, or any session-related 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 focused sentence with no fluff. It states the action first and immediately follows with the critical safety condition. 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?

The tool is simple and has an output schema, so return details are not needed. The critical confirmation requirement is present, and required parameters are identifiable. Still, without annotations, the description leaves out important behavioral context such as permanence and error behavior.

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 to confirm by stating it is required, which goes beyond the schema's default of false. index and doc_id are self-explanatory from their names, but session_name remains unexplained.

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 and resource: 'Delete one Elasticsearch document.' This distinguishes it from siblings like es_search, es_index_document, mongo_delete, and redis_delete by specifying the exact system and operation.

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

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

The description gives an explicit prerequisite: 'confirm=true is required.' This tells the agent how to safely invoke the tool. It does not explicitly contrast with alternative tools, but the operation itself makes the use case 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 available, the description carries the full burden of behavioral disclosure. It only notes doc_id omission for auto-assignment, but omits that this is a write/mutation operation, potential errors (e.g., missing index), or side effects. For a mutation tool, this is a significant gap.

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

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

The description is exactly two sentences with no fluff. The primary action is front-loaded, and the additional doc_id note is concise. Every word earns its place, making it highly efficient.

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

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

Given four parameters (two required), an output schema, and a write operation, the description is far too brief. It fails to explain the format of document_json, the meaning of index, or what the tool returns. An agent would have to guess the semantics of essential inputs, leaving the tool under-specified.

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

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

Schema description coverage is 0%, so the description must compensate, but it only touches doc_id ('Omit doc_id...'). It does not explain index, document_json, or session_name at all. The added value is minimal and leaves three of four parameters semantically unexplained.

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 and object: 'Index one Elasticsearch document.' It also adds behavioral detail about omitting doc_id, which spreads the scope precisely. Among sibling tools (es_search, es_delete_document), the verb 'index' uniquely identifies this operation, so no confusion is likely.

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

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

No guidance is provided on when to use this tool versus alternatives. The description does not mention that es_search is for querying, es_delete_document for removals, or any specific scenario that selects this tool. It is purely procedural without contextual selection criteria.

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

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

With no annotations, the description carries the full burden, but it only states 'Search an Elasticsearch index.' It doesn't disclose that the tool is read-only, that it may require a connection established via session_name, or how results are returned. The description adds minimal behavioral context beyond the name.

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

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

The description is a single sentence with no redundant words, which is concise. However, it may be too sparse given the tool's complexity, but for the purpose of conciseness, it is efficient.

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

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

The tool has an output schema, so return format is covered, but the description lacks essential context: it doesn't explain how to construct a query, what the default behavior is, or whether a connection is required. The session_name parameter hints at connection management, but it's not explained. Overall, an agent would struggle to use this tool correctly without additional information.

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

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

Schema coverage is 0%, and the description does not explain any of the three parameters. The schema provides types and defaults, but the description adds no meaning to index, query_json, or session_name. The agent must guess that query_json expects an Elasticsearch query DSL string and that session_name identifies a connection.

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

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

The description states a clear action (search) and a specific resource (Elasticsearch index), which distinguishes it from sibling tools like db_query and mongo_find. However, it doesn't elaborate on the search capabilities, such as querying with custom JSON, but the core purpose is 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?

There is no guidance on when to use this tool versus alternatives. It doesn't mention that this is for Elasticsearch only, or that it requires an active session, or contrast it with es_index_document or es_delete_document. The agent is left to infer usage from the name.

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

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

With no annotations, the description must disclose behavioral traits. It states the destructive action and the confirm requirement, but it doesn't clarify that all matching documents are deleted, that the operation is irreversible, or that permissions may be needed. The ambiguity of 'documents' (plural) without specifying 'all' is a gap.

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

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

The description is two short sentences with no fluff. It front-loads the action and includes the critical confirm requirement. It is appropriately concise for a simple destructive operation, though it omits necessary details covered under other dimensions.

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 destructive nature, no annotations, and 0% schema coverage, this description is incomplete. It doesn't mention that all matching documents are deleted, the need for an active connection, or the output/result of the operation (though an output schema exists, it's not referenced). The agent lacks critical information to invoke this safely and correctly.

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

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

Schema description coverage is 0%, so the description must explain parameters. It only addresses filter_json (non-empty) and confirm (required), but leaves database, collection, and session_name undefined. The format of filter_json (e.g., JSON query syntax) is not explained, making it hard for an agent to construct valid input.

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

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

The description clearly states the verb 'Delete', the resource 'MongoDB documents', and the condition 'matching a non-empty filter'. This distinguishes it from sibling tools like mongo_find (read) and mongo_insert (insert). The purpose is 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 guidance on when to use this tool versus alternatives. It doesn't mention prerequisites like an active connection (see db_connect sibling) or recommend previewing with mongo_find. The only usage note is the confirm=true requirement, which is a safety gate, not a selection criterion.

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

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

No annotations are provided, so the description carries full responsibility. It reveals nothing about read-only nature, pagination, limits, session handling, or return format—critical for a database operation.

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

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

The description is extremely short, which is concise, but it is under-specified rather than efficient. There is no useful information beyond the name, so it fails to earn its place.

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

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

For a tool with 5 parameters, an output schema, and no annotations, the description is completely inadequate. An agent cannot determine how to construct a query, interpret results, or handle sessions.

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

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

Schema description coverage is 0%, and the description mentions none of the 5 parameters (database, collection, filter_json, limit, session_name). It adds zero semantic value beyond the schema names.

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 verb and resource ('Find MongoDB documents') but does not differentiate from sibling tools like mongo_list_collections or db_query. It is barely more than a restatement of the tool name, offering no scope or specifics about what kinds of documents or filtering.

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

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

No guidance is given on when to use this tool versus alternatives. With siblings like db_query, mongo_insert, and mongo_update, the description leaves the agent without any basis for 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?

No annotations are provided, so the description carries the full burden of behavioral disclosure. 'Insert' implies a write operation, but the description does not state what happens on duplicate _id, whether an existing connection is required, whether the JSON is validated, or whether the inserted document/ID is returned. Key operational context is missing.

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

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

Four words with zero filler; the action and target are front-loaded and every word earns its place. For a tool of this simplicity, this is an optimally concise definition.

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 having an output schema and relatively simple inputs, the definition lacks essential context: no usage guidance, no behavioral side effects, and no parameter format details. With zero annotations and 0% schema description coverage, the sparse description leaves meaningful gaps an agent must guess around.

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

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

Schema description coverage is 0%, so the description must compensate, but it barely does. It implies document_json holds the document, yet it does not clarify that it must be a valid JSON string, its expected structure, or how session_name interacts with connection state. The meanings of database and collection are left entirely to their property names.

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 ('Insert') and a specific resource ('one MongoDB document'), clearly identifying the operation. It distinguishes from the db_insert sibling by naming MongoDB and from mongo_find/update/delete by the insert verb, though this differentiation is implicit rather than explicit.

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

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

No guidance is given on when to use this tool versus alternatives such as db_insert or mongo_update, and no prerequisites are mentioned (e.g., whether a connection or session must be established first). The agent must infer usage entirely from the tool name and schema.

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 fully disclose behavior. It only states the basic function without mentioning connection requirements, error handling, or output format. Given the presence of an output schema, some behavior is inferred, but the description fails to convey important operational context, such as whether a connection is required or how it handles non-existent 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?

The description is a single, concise sentence that is front-loaded and free of unnecessary words. It efficiently conveys the core purpose without verbosity.

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

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

Given the tool's low complexity (2 parameters, no nested objects) and the presence of an output schema, the description is minimal but lacks critical details for proper usage. It doesn't specify prerequisites like a valid connection, how to select the right database, or interactions with session management, which are likely relevant given the 'session_name' parameter. More guidance is needed for an agent to use 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 0%, meaning the schema only provides parameter names and types. The description mentions 'database' implicitly but does not add meaning beyond the schema for the 'database' parameter, and 'session_name' is entirely unexplained. However, with only this minimal description, it does provide some context that the tool operates on a database, which is a slight improvement over bare schema.

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

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

The description states a specific verb ('List') and resource ('collections in a MongoDB database'), clearly indicating the tool's purpose. However, it doesn't explicitly differentiate from the sibling tool 'db_list_tables', which also lists database objects, leaving some potential ambiguity for agents distinguishing between SQL and MongoDB contexts.

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 like 'db_list_tables' or 'mongo_list_databases'. The context signals show many sibling tools, and without explicit usage instructions, the agent must infer that this tool is for MongoDB collections specifically, which is a clear gap.

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. 'List' implies a read-only operation, but the description does not explicitly state that it makes no changes, requires an existing connection/session, or how session_name affects execution. It adds minimal context and is not misleading, but it leaves important behavioral details unstated.

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

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

The description is a single clear sentence with no wasted words. It states the operation and the output target immediately, making it easy for an agent to parse and act on.

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 and has an output schema, so return values need not be described. However, the description omits important operational context such as the role of session_name, whether an active connection is required, and how this tool relates to mongo_list_collections. It is minimally viable but leaves gaps for correct invocation in a multi-session environment.

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

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

Schema description coverage is 0%, so the description must compensate for the undocumented session_name parameter, but it does not mention it at all. The parameter name 'Session Name' and its default value offer some clue, but the description adds no semantic value about how session_name is used or why it matters.

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 and resource: 'List MongoDB database names.' It clearly indicates what the tool returns and distinguishes it from sibling tools like mongo_list_collections and db_list_tables by explicitly naming databases. However, it does not explicitly contrast itself with those siblings, so it stops short of a top score.

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 about when to use this tool versus alternatives such as mongo_list_collections or db_list_tables. There is no mention of prerequisites like an active connection or session, nor any exclusions or preferred usage context. The usage is only implied by the name and description.

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 behavioral burden. It does disclose that empty filters are refused, which is useful, and that update_json should use operators like $set. However, it omits critical behaviors: whether it updates a single document or multiple, whether it returns a result (e.g., modified count), and how it handles errors like invalid JSON or missing collections. These gaps could lead an agent to misuse the 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 concise, using only two sentences with no fluff. The purpose is front-loaded, and the key constraint about update_json is stated clearly. However, it could be slightly more structured by separating the behavioral warning (empty filters) into its own sentence for emphasis, but overall it is appropriately sized.

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 has 5 parameters, no annotations, no parameter descriptions, and only a minimal description. While an output schema exists (which might cover return values), the description does not address important context: whether updates are limited to one document, whether a connection is required, or what happens when no documents match the filter. The description is too sparse for a mutation tool that could have significant side effects.

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 by explaining parameters. It adds meaning to update_json by specifying the need for operators like $set, and it implies filter_json must not be empty. But it offers no explanation for database, collection, or session_name. Given the zero coverage, this is insufficient; an agent would have to infer the meaning of most parameters from their names alone.

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 updates MongoDB documents, which distinguishes it from read, insert, and delete siblings like mongo_find, mongo_insert, and mongo_delete. However, it does not explicitly mention that it updates documents matching a filter, which is a minor specificity gap given the filter_json parameter.

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 db_update (for SQL) or other mongo_* tools. It does not mention prerequisites like an active connection, nor does it suggest pairing with mongo_find for verification. The only usage hint is the requirement that update_json include operators like $set, but that pertains to parameter formatting rather 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 must disclose behavior. It only states 'DEL a Redis key,' implying a destructive operation, but does not mention permanence, return value, or any side effects. For a mutation tool, this is insufficient transparency.

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

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

The description is a single concise sentence with no wasted words. It is appropriately brief for a simple operation, front-loading the core action. There is no redundancy or unnecessary detail.

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

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

Given the tool's destructive nature and lack of annotations, the description is incomplete. It doesn't explain what happens after deletion (e.g., return value), whether the operation is irreversible, or the purpose of 'session_name'. An output schema exists but is not referenced in the description, so the agent may not understand the expected response. More context is needed for safe and correct use.

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

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

Schema description coverage is 0%, and the description adds no meaning to parameters. 'key' is self-explanatory from the schema, but 'session_name' is not explained, and the description does not clarify how it affects the operation. The tool relies entirely on schema definitions, which are minimal.

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 'DEL a Redis key' uses the specific Redis command 'DEL' and names the resource (key), clearly indicating a delete operation. It distinguishes from sibling tools like redis_get and redis_set by the action, though it could be more explicit about deleting a single key vs multiple.

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

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

No guidance is provided on when to use this tool versus alternatives. It doesn't mention that it's for removing a specific key, or when one might prefer redis_set or other delete tools. No exclusions or context 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, the description must disclose behavior but only says 'GET a Redis key.' It doesn't state that it returns the value, handles missing keys, or requires a session. This is nearly tautological and provides no meaningful behavioral context.

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

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

The description is extremely short but under-specified. While concise, it lacks structure and essential information, making it closer to a placeholder than a helpful definition.

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 low schema coverage and no annotations, the description fails to provide necessary context such as return format, error behavior, or session handling. It is incomplete for an agent to invoke correctly.

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

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

Schema description coverage is 0% and the description mentions no parameters. The tool has two parameters (key, session_name) with no explanation of their semantics or defaults, leaving the agent to guess.

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

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

The description 'GET a Redis key' states a specific verb and resource, making the tool's purpose clear. It implicitly distinguishes from siblings like redis_set, redis_delete, and redis_keys by naming the operation, though it doesn't explicitly call out alternatives.

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

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

No guidance is provided on when to use this tool versus alternatives. The description gives no context about scenarios (e.g., retrieving a value vs listing keys) or prerequisites like needing a connection or session.

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

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

With no annotations, the description must disclose behavioral traits. It mentions the 200-key cap, which is a useful limit, but omits critical details: it does not state that this is a read-only operation, does not explain Redis glob pattern syntax, does not address the session_name parameter's role, and does not clarify what happens when the cap is exceeded (e.g., truncation without warning). These gaps are significant for a tool with no annotation support.

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, direct sentence that front-loads the action and includes the key constraint (capped at 200). It avoids filler and is efficient for an agent to parse.

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 being a simple tool, the description leaves essential context missing. It does not explain the pattern semantics, the purpose of session_name, or the implication of the cap. The presence of an output schema reduces the need to document return values, but parameter semantics and usage context are still under-specified for a tool with no annotations.

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

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

The schema provides no descriptions for pattern or session_name, and the description adds no explanation of either. Pattern is only a default '*' with no mention of Redis pattern rules; session_name is completely unexplained. With 0% schema description coverage, the description should compensate, but it does not.

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

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

The description states a clear verb (list) and resource (Redis keys) with a specific qualifier (matching a pattern, capped at 200). It is distinct from siblings like redis_get, redis_set, and redis_delete, which operate on individual keys rather than enumerating them.

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 offers no guidance on when to use this tool over alternatives. It does not mention that it is a discovery tool for key exploration, nor does it contrast with redis_get or other listing tools like db_list_tables. Agents are left to infer use cases from the name and description alone.

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

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

With no annotations, the description carries the full burden of disclosing side effects. It only says 'SET a Redis key,' which implies mutation but doesn't state whether it overwrites existing keys, whether it requires an existing connection, or what the return value is. No behavioral traits beyond the core operation are disclosed.

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

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

The description is extremely short (4 words), but this is under-specification rather than effective conciseness. Every sentence is minimal, but it lacks substance. It has no structure or front-loading of key information.

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

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

Despite having an output schema, the tool is a 3-parameter mutation with no annotations or parameter descriptions. The description omits critical context like overwrite semantics, session name purpose, and connection requirements. For a write operation with zero annotation coverage, this is completely inadequate.

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 explain the parameters. It only references 'key' implicitly and gives no explanation of 'value' or 'session_name'. The description fails to compensate for the complete lack of parameter documentation in the schema.

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

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

The description 'SET a Redis key' clearly indicates a write operation on a Redis key, which distinguishes it from siblings like redis_get, redis_delete, and redis_keys through the verb. However, it is minimal and doesn't explicitly contrast with alternatives or mention the value parameter. It is clear but lacks explicit sibling differentiation.

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

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

No information is provided about when to use this tool versus redis_get or redis_delete. There is no mention of prerequisites, such as an active Redis connection, or any conditions. The description offers zero usage guidance.

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