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

The description adds valuable behavioral context beyond the annotations: it mentions the responseBytesLimit constraint and server-side capping, plus the alternative 'export' tool for larger results. While annotations already declare readOnlyHint=true and destructiveHint=false, the description provides practical implementation details about result size limitations that aren't captured in structured fields.

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 - a single sentence that directly states the tool's purpose without any unnecessary elaboration. Every word earns its place, and the structure is front-loaded with the core functionality. This is model efficiency in description writing.

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 aggregation tool with good annotations and full schema coverage, the description is minimally complete. It covers the basic purpose and hints at result size limitations, but lacks information about return format, error conditions, or performance characteristics. Without an output schema, more guidance about what the aggregation returns would be helpful for agent understanding.

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

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

With 100% schema description coverage, the input schema already documents all parameters thoroughly. The description doesn't add meaningful parameter semantics beyond what's in the schema - it mentions aggregation generally but provides no additional context about pipeline construction, database/collection selection, or response limit implications beyond what the schema descriptions already state.

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

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

The description clearly states the action ('Run an aggregation') and target ('against a MongoDB collection'), providing a specific verb+resource combination. However, it doesn't explicitly differentiate this tool from sibling tools like 'find' or 'count' which also query MongoDB collections, missing an opportunity for clearer distinction.

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 some implied usage context through the responseBytesLimit parameter note about using the 'export' tool for larger results, but lacks explicit guidance on when to choose this tool over alternatives like 'find' or 'count'. No clear when/when-not instructions or sibling tool comparisons are provided.

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

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

Annotations indicate readOnlyHint=true and destructiveHint=false, so the agent knows this is a safe read operation. The description adds no behavioral context beyond this, such as rate limits, authentication needs, or what 'Describe' entails (e.g., returns index details). It does not contradict annotations, but offers minimal value beyond them.

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

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

The description is a single, efficient sentence with no wasted words. It is front-loaded, immediately stating the tool's purpose without unnecessary elaboration. Every part of the sentence earns its place by conveying essential information directly.

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 output schema) and rich annotations (read-only, non-destructive), the description is minimally adequate. It states what the tool does but lacks details on output format or usage context. For a simple read tool, this is acceptable but leaves gaps in guiding the agent fully.

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 clear descriptions for 'database' and 'collection' parameters. The description does not add meaning beyond the schema, such as explaining parameter relationships or constraints. With high schema coverage, the baseline score of 3 is appropriate, as the schema handles parameter documentation adequately.

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

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

The description 'Describe the indexes for a collection' states the tool's purpose clearly with a verb ('Describe') and resource ('indexes for a collection'), but it does not differentiate from siblings like 'collection-schema' or 'collection-storage-size', which also describe collection metadata. It avoids tautology by specifying what is described (indexes), but lacks specificity on scope or format.

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 does not mention prerequisites, such as needing an existing database and collection, or compare it to siblings like 'list-collections' for broader metadata. Without explicit when/when-not instructions, the agent must infer usage from context 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?

Annotations indicate readOnlyHint=true and destructiveHint=false, so the agent knows this is a safe read operation. The description adds context about schema inference (sampling documents), which isn't covered by annotations. However, it doesn't disclose behavioral traits like rate limits, authentication needs, or what happens if the collection doesn't exist. With annotations covering safety, a 3 is appropriate—some added value but limited behavioral detail.

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

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

The description is a single, efficient sentence: 'Describe the schema for a collection.' It's front-loaded with the core purpose, has zero wasted words, and is appropriately sized for a tool with clear annotations and schema. 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?

Given the tool's complexity (schema inference with sampling), annotations cover safety, and schema coverage is 100%, the description is minimally adequate. However, with no output schema, it doesn't explain what the schema description includes (e.g., field types, nested structures) or potential limitations (e.g., inference accuracy). For a read-only tool with good schema support, it meets basic needs but lacks depth.

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 all four parameters (database, collection, sampleSize, responseBytesLimit). The description doesn't add any parameter-specific semantics beyond what the schema provides (e.g., it doesn't explain how sampleSize affects accuracy or what responseBytesLimit entails). Baseline 3 is correct 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?

The description clearly states the tool's purpose: 'Describe the schema for a collection' specifies the verb ('describe') and resource ('schema for a collection'). It distinguishes from siblings like 'collection-indexes' or 'collection-storage-size' by focusing on schema inference rather than indexes or storage metrics. However, it doesn't explicitly differentiate from 'list-collections' or 'find', which might also involve schema-related operations.

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 (e.g., needing database/collection names), exclusions, or compare to siblings like 'find' (which might return data samples) or 'list-collections' (which lists collections without schema details). Usage is implied but not explicitly 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 indicate readOnlyHint=true and destructiveHint=false, so the agent knows this is a safe read operation. The description adds no behavioral context beyond this, such as performance implications, rate limits, or what the size measurement includes (e.g., storage vs. document count). With annotations covering safety, a baseline score is appropriate, but more detail would enhance 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 extremely concise with a single, direct sentence that front-loads the core purpose. There's no wasted language or redundancy, making it efficient for quick understanding, though this conciseness comes at the cost of omitted details like usage guidelines.

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 required parameters, no output schema) and rich annotations (readOnlyHint, destructiveHint), the description is minimally adequate. However, it lacks context on return values (e.g., size units, format) and doesn't leverage the absence of an output schema to explain what the tool returns, leaving gaps in completeness for agent invocation.

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

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

Schema description coverage is 100%, with clear documentation for both 'database' and 'collection' parameters. The description doesn't add any semantic details beyond what the schema provides, such as examples or constraints on valid names. Since the schema handles parameter documentation adequately, the baseline score reflects no additional value from the description.

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

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

The description clearly states the tool's purpose with a specific verb ('Gets') and resource ('size of the collection'), making it immediately understandable. However, it doesn't explicitly differentiate from sibling tools like 'db-stats' or 'collection-schema', which might also provide size-related information, leaving some ambiguity about uniqueness.

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, such as needing an existing database and collection, or compare it to sibling tools like 'db-stats' for broader database statistics, leaving the agent to infer usage context independently.

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 indicate readOnlyHint=true and destructiveHint=false, which the description aligns with by describing a connection-establishment action without implying data modification. The description adds context about checking existing connections and switching clusters, which is useful beyond annotations. However, it lacks details on error handling, timeout behavior, or authentication requirements that aren't covered by annotations.

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

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

The description is concise and well-structured, consisting of two sentences that efficiently convey purpose and usage guidelines. Every sentence adds value: the first states the core function, and the second provides critical context about when to use or avoid the tool. There is no redundant or unnecessary information.

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

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

Given the tool's moderate complexity (connection management), the description is reasonably complete. It covers purpose, usage conditions, and existing connection checks. However, without an output schema, it doesn't describe what happens after connection (e.g., success/failure responses), and annotations only cover safety aspects. For a connection tool, more behavioral details (like error cases) would enhance completeness.

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

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

The input schema has 100% description coverage, with the 'connectionString' parameter fully documented in the schema. The description doesn't add any parameter-specific details beyond what the schema provides, such as format examples or validation rules. With high schema coverage, a baseline score of 3 is appropriate as the description doesn't compensate but doesn't need to.

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

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

The description clearly states the tool's purpose: 'Connect to a MongoDB instance.' It specifies the verb ('Connect') and resource ('MongoDB instance'), making the intent unambiguous. However, it doesn't explicitly differentiate from sibling tools like 'atlas-connect-cluster', which might serve a similar purpose but for Atlas-specific connections.

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 explicit guidance on when to use this tool: 'If the user has configured a connection string or has previously called the connect tool, a connection is already established and there's no need to call this tool unless the user has explicitly requested to switch to a new MongoDB cluster.' It clearly states conditions for usage and non-usage, helping the agent avoid redundant calls.

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 provide readOnlyHint=true and destructiveHint=false, indicating a safe read operation. The description adds value by specifying the MongoDB method used ('db.collection.count()') and that the query is optional, which gives context beyond annotations. However, it doesn't disclose additional behavioral traits like performance implications, rate limits, or error handling. No contradiction with annotations exists.

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

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

The description is a single, efficient sentence that front-loads the core purpose and includes key details (MongoDB method and optional query). There is no wasted text, and it's appropriately sized for the tool's complexity. Every part of the sentence contributes to understanding the tool's function.

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

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

Given the tool's moderate complexity (3 parameters, nested object in query), annotations cover safety, and schema coverage is high, the description is adequate but has gaps. It lacks details on output (e.g., what the count returns, error cases) and doesn't fully address behavioral context like performance. For a read-only tool with good schema support, it meets minimum viability but could be more 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 100%, with clear descriptions for 'database', 'collection', and 'query'. The description adds minimal semantics by noting the query is 'optional' and matches 'db.collection.count()' syntax, but this is largely redundant with the schema's details. Since schema coverage is high, the baseline score of 3 is appropriate, as the description doesn't significantly enhance parameter understanding.

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

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

The description clearly states the tool's purpose: 'Gets the number of documents in a MongoDB collection' with a specific verb ('Gets') and resource ('documents in a MongoDB collection'). It distinguishes from siblings like 'find' or 'aggregate' by focusing on counting rather than retrieving or processing documents. However, it doesn't explicitly differentiate from all siblings (e.g., 'db-stats' might also provide counts in a broader context).

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

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

The description implies usage by mentioning 'query as an optional filter parameter' for filtering documents, suggesting when to use it for filtered counts. However, it doesn't provide explicit guidance on when to choose this tool over alternatives like 'aggregate' for counting or other siblings, nor does it specify prerequisites or exclusions. The context is clear but lacks detailed alternatives.

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

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

Annotations indicate readOnlyHint=false and destructiveHint=false, covering the safety profile. The description adds value by disclosing the automatic database creation behavior, which is a key trait not covered by annotations. It doesn't detail other behaviors like error handling or permissions, but with annotations present, this is adequate.

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

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

The description is two sentences, front-loaded with the main action and followed by a critical behavioral detail. Every word contributes essential information without redundancy, making it highly efficient and well-structured.

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

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

Given the tool's moderate complexity (creation with side effects), no output schema, and rich annotations, the description is mostly complete. It covers the core action and a key behavioral trait, but could benefit from mentioning potential outcomes or errors, though annotations help mitigate this gap.

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

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

Schema description coverage is 100%, with both parameters ('database' and 'collection') well-documented in the schema. The description doesn't add any additional meaning or examples beyond what the schema provides, such as format constraints or naming rules, so it meets the baseline for high coverage.

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

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

The description clearly states the action ('Creates a new collection') and resource ('in a database'), distinguishing it from siblings like 'list-collections' or 'drop-collection'. It specifies the scope of creation, making the purpose explicit and distinct.

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

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

The description provides clear context for usage by mentioning automatic database creation if it doesn't exist, which is useful guidance. However, it doesn't explicitly state when to use this tool versus alternatives like 'insert-many' or 'rename-collection', or any prerequisites beyond the parameters.

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 indicate this is a non-readOnly, non-destructive operation (readOnlyHint=false, destructiveHint=false), which the description doesn't contradict. The description adds minimal behavioral context beyond annotations—it doesn't specify performance impact, permissions needed, or what happens if the index already exists. With annotations covering safety, this meets baseline expectations.

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

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

The description is a single, efficient sentence that directly states the tool's purpose without unnecessary words. It's front-loaded and wastes no space, making it easy to parse quickly.

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 4 parameters, 100% schema coverage, and annotations covering safety, the description is minimally adequate. However, it lacks output information (no output schema) and doesn't address key behavioral aspects like error conditions or indexing best practices, leaving gaps in completeness.

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

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

Schema description coverage is 100%, so all parameters are documented in the schema. The description doesn't add any meaning beyond what the schema provides (e.g., it doesn't explain index types or usage scenarios). This meets the baseline score for high schema coverage.

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

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

The description clearly states the action ('create') and resource ('index for a collection'), making the purpose immediately understandable. It distinguishes from siblings like 'drop-index' (deletion) and 'collection-indexes' (listing), but doesn't explicitly differentiate from other creation tools like 'create-collection' beyond the resource type.

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 doesn't mention prerequisites (e.g., existing database/collection), when indexing is beneficial, or when to choose this over other indexing-related tools like 'drop-index' or 'collection-indexes'.

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 indicate readOnlyHint=true and destructiveHint=false, so the agent knows this is a safe read operation. The description adds value by specifying that it returns 'statistics' and focuses on 'use state', which provides context beyond the annotations. However, it lacks details on rate limits, authentication needs, or error handling, leaving some behavioral aspects unclear.

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

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

The description is a single, efficient sentence that directly states the tool's function without unnecessary words. It is front-loaded with the core action ('Returns statistics'), making it easy to understand at a glance. Every part of the sentence contributes to clarifying the purpose.

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

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

Given the tool's low complexity (1 parameter, no output schema) and good annotations, the description is somewhat complete but has gaps. It lacks details on what specific statistics are returned (e.g., size, query counts) or how to interpret them, which could be important for users. With no output schema, more elaboration on return values would be beneficial.

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

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

The input schema has 100% description coverage, with the 'database' parameter clearly documented. The description does not add any additional meaning beyond the schema, such as explaining what constitutes a valid database name or examples. Since the schema does the heavy lifting, a baseline score of 3 is appropriate.

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

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

The description clearly states the tool's purpose with a specific verb ('Returns') and resource ('statistics'), and specifies the scope ('use state of a single database'). However, it does not explicitly differentiate this tool from potential siblings like 'list-databases' or 'collection-storage-size', which might also provide database-related information, so it falls short of a perfect 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?

The description provides no guidance on when to use this tool versus alternatives. It does not mention prerequisites, such as needing an existing database, or compare it to sibling tools like 'list-databases' for broader information. Without such context, users might struggle to select the appropriate tool.

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

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

Annotations already declare destructiveHint=true and readOnlyHint=false, so the agent knows this is a destructive write operation. The description adds valuable context by specifying it removes 'all documents that match the filter' (not just one) and references MongoDB's deleteMany() syntax, which helps anticipate behavior. However, it doesn't mention permissions needed, atomicity, or what happens on empty filters.

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

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

The description is a single, efficient sentence that front-loads the core action ('Removes all documents') and includes essential technical context (MongoDB collection, filter matching deleteMany syntax). Every word earns its place with no redundancy.

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

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

For a destructive tool with good annotations (destructiveHint=true) and full schema coverage, the description is reasonably complete—it clarifies scope and references MongoDB syntax. However, without an output schema, it doesn't describe return values (e.g., deletion count), and it lacks guidance on error conditions or permissions, leaving some gaps for a high-stakes operation.

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

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

Schema description coverage is 100%, with clear descriptions for database, collection, and filter parameters. The description adds marginal value by mentioning the filter 'matches the syntax of db.collection.deleteMany()', but doesn't provide additional syntax examples or constraints beyond what the schema already documents.

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 ('Removes all documents'), the resource ('from a MongoDB collection'), and the scope ('that match the filter'), distinguishing it from siblings like drop-collection (which removes the entire collection) or update-many (which modifies rather than deletes).

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

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

The description implies usage for deleting multiple documents based on a filter, but doesn't explicitly state when to use this vs. alternatives like drop-collection (for entire collections) or update-many (for modifications). No guidance on prerequisites or exclusions is provided.

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

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

Annotations already declare destructiveHint=true and readOnlyHint=false, indicating a destructive write operation. The description adds valuable behavioral context by specifying that associated indexes are also removed, which goes beyond the annotations. However, it doesn't mention permissions needed, irreversibility, or confirmation 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 two concise sentences with zero wasted words. The first sentence states the core action and resource, while the second adds important behavioral detail about index removal. 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 destructive tool with good annotations (destructiveHint=true) but no output schema, the description provides adequate context about what gets removed. However, it could better address the irreversible nature or potential data loss implications to help the agent understand the severity of this operation.

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

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

Schema description coverage is 100%, with both parameters ('database' and 'collection') clearly documented in the schema. The description doesn't add any parameter-specific information beyond what the schema provides, so it meets the baseline for high schema coverage.

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

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

The description clearly states the action ('Removes') and resource ('a collection or view from the database'), distinguishing it from siblings like 'drop-database' (removes entire database) or 'rename-collection' (renames rather than removes). It also specifies that associated indexes are removed, adding important scope details.

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

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

The description implies usage context by specifying what gets removed (collection/view and associated indexes), but doesn't explicitly state when to use this vs. alternatives like 'drop-database' or 'delete-many'. It provides clear scope but lacks explicit comparative 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 indicate destructiveHint=true and readOnlyHint=false, but the description adds valuable context by specifying that data files are deleted, which clarifies the irreversible nature beyond just 'destructive'. It doesn't mention permissions, rate limits, or confirmation steps, but the added detail about data files enhances 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, efficient sentence that front-loads the core action ('Removes the specified database') and adds necessary detail ('deleting the associated data files') without any wasted words. Every part earns its place by clarifying scope and impact.

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 no output schema, the description adequately covers the action and data deletion, but lacks details on return values, error conditions, or dependencies. Given the high-risk nature, more context on irreversible effects or success indicators would improve completeness, but it's minimally viable.

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

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

Schema description coverage is 100%, with the parameter 'database' fully documented in the schema as 'Database name'. The description does not add any additional meaning or examples beyond what the schema provides, so it meets the baseline for high schema coverage without extra value.

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

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

The description clearly states the action ('Removes') and the resource ('the specified database'), and distinguishes it from sibling tools like 'drop-collection' by specifying database-level deletion rather than collection-level. It's specific about what gets affected ('deleting the associated data files').

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 'drop-collection' or 'delete-many', nor does it mention prerequisites such as ensuring the database exists or is not in use. It lacks explicit when/when-not instructions or named alternatives.

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

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

Annotations indicate destructiveHint=true and readOnlyHint=false, which the description aligns with by using 'Drop' (implying mutation and destruction). The description adds minimal context beyond annotations, specifying the database and collection scope but not detailing effects like performance impacts or irreversibility.

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

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

The description is a single, efficient sentence that front-loads the core action ('Drop an index') and essential parameters. There is no wasted verbiage, making it easy to parse quickly.

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 no output schema, the description is minimal but covers the basic operation. It lacks details on behavioral outcomes (e.g., what happens post-drop, error conditions) and doesn't compensate for the absence of output schema, though annotations provide some safety context.

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 parameters are fully documented in the schema. The description mentions 'database and collection' and 'indexName' but adds no extra meaning beyond schema details like constraints (e.g., minLength for indexName) or the fixed 'type' 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 ('Drop') and target ('an index'), specifying the required database and collection context. It distinguishes from siblings like 'create-index' and 'collection-indexes' by focusing on deletion rather than creation or listing, though it doesn't explicitly contrast with 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?

No guidance is provided on when to use this tool versus alternatives. While the purpose implies it's for removing indexes, there's no mention of prerequisites (e.g., ensuring the index exists), consequences, or when to choose other tools like 'collection-indexes' for inspection first.

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 indicate readOnlyHint=true and destructiveHint=false, so the agent knows this is a safe read operation. The description adds that it 'returns statistics,' which aligns with annotations. However, it doesn't disclose additional behavioral traits like performance impact (e.g., whether running explain affects database load), output format details (since no output schema exists), or any rate limits. With annotations covering safety, the description adds minimal context beyond them.

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, well-structured sentence that efficiently conveys the core functionality: 'Returns statistics describing the execution of the winning plan chosen by the query optimizer for the evaluated method.' It's front-loaded with the main action ('returns statistics') and avoids unnecessary words, making it highly concise and easy 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?

Given the tool's complexity (analyzing query execution with multiple method types) and rich schema (100% coverage, detailed parameter docs), the description is adequate but minimal. It lacks output details (no output schema provided), doesn't explain the relationship to sibling tools like 'export' for full results, and omits practical use cases. For a tool with no output schema and moderate complexity, it should provide more context on what 'statistics' entail and when to use 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 fully documents all 4 parameters (database, collection, method, verbosity) with detailed descriptions. The description doesn't add any parameter-specific information beyond what's in the schema, such as clarifying how 'method' relates to query execution or examples of use. Baseline 3 is appropriate 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?

The description clearly states the tool's purpose: 'Returns statistics describing the execution of the winning plan chosen by the query optimizer for the evaluated method.' It specifies the verb ('returns statistics'), resource ('execution of the winning plan'), and scope ('for the evaluated method'), making it clear this is an analysis tool. However, it doesn't explicitly differentiate from sibling tools like 'atlas-get-performance-advisor' or 'mongodb-logs' which might also provide performance insights.

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 (e.g., needing an existing query to analyze), compare it to sibling tools like 'export' (referenced in the schema) for full results, or specify scenarios where explain plans are useful (e.g., query optimization, debugging). Usage is implied but not explicitly 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 readOnlyHint=true and destructiveHint=false, so the agent knows this is a safe read operation. The description adds that it exports results in EJSON format, which provides useful context about output behavior. However, it doesn't mention potential limitations like export size constraints, performance implications, or authentication requirements beyond what annotations cover.

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

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

The description is a single, efficient sentence that clearly states the tool's purpose without unnecessary words. It's front-loaded with the core functionality and includes essential details about format. Every element serves a purpose with zero waste.

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 export tool with comprehensive schema documentation (100% coverage) and clear annotations, the description provides adequate context. It specifies the output format (EJSON) which is crucial for understanding the tool's behavior. However, without an output schema, some additional detail about the export result structure or potential limitations would be helpful for full completeness.

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

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

Schema description coverage is 100%, so the schema already thoroughly documents all 5 parameters. The description mentions 'query or aggregation results' which aligns with the exportTarget parameter's structure, but adds no additional semantic context beyond what's in the schema. With complete schema documentation, the baseline score of 3 is appropriate.

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

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

The description clearly states the action ('Export') and the target ('a query or aggregation results') with the output format specified ('EJSON format'). It distinguishes from sibling tools like 'find' and 'aggregate' by focusing on export functionality rather than direct query execution. However, it doesn't explicitly contrast with all potential export-related alternatives that might exist.

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

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

The description implies usage for exporting query/aggregation results in EJSON format, but doesn't explicitly state when to use this tool versus alternatives like direct 'find' or 'aggregate' tools. The schema's 'responseBytesLimit' notes suggest using 'export' for entire results, but this guidance isn't in the description itself. No explicit when-not-to-use or prerequisite information is provided.

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

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

Annotations already declare readOnlyHint=true and destructiveHint=false, so the agent knows this is a safe read operation. The description adds minimal behavioral context beyond this - it mentions it's a 'find query' which implies document retrieval, but doesn't disclose rate limits, authentication requirements, or what happens when responseBytesLimit is exceeded. With annotations covering safety, 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?

The description is a single, efficient sentence with zero wasted words. It's appropriately sized for a tool with comprehensive schema documentation and gets straight to the point without unnecessary elaboration.

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

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

Given the tool's complexity (7 parameters, nested objects) and lack of output schema, the description is minimally adequate. The annotations cover safety, and the schema documents parameters thoroughly, but the description doesn't help the agent understand result formats, error conditions, or practical usage patterns. For a query tool with no output schema, more context would be helpful.

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 each parameter well-documented in the schema itself. The description doesn't add any meaningful parameter semantics beyond what's already in the schema - it mentions 'find query' which aligns with the schema's documentation but provides no additional syntax examples, format details, or usage patterns. Baseline 3 is correct when schema does all the work.

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 ('Run a find query') and target ('against a MongoDB collection'), providing a specific verb+resource combination. However, it doesn't explicitly distinguish this from sibling tools like 'count' or 'export' that also query MongoDB collections, which prevents a perfect 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?

The description provides no guidance on when to use this tool versus alternatives. It doesn't mention sibling tools like 'count' for counting documents, 'export' for larger result sets, or 'aggregate' for complex queries. There's no context about appropriate use cases or limitations.

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 indicate this is a write operation (readOnlyHint: false) but non-destructive (destructiveHint: false). The description adds value by specifying it's for MongoDB and references 'db.collection.insertMany()' syntax, hinting at MongoDB-specific behavior. However, it lacks details on atomicity, error handling, or performance implications of bulk insertion.

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

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

The description is a single, efficient sentence that directly states the tool's purpose. It's front-loaded with the core action and includes a helpful MongoDB reference without unnecessary elaboration.

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 write tool with no output schema and 100% schema coverage, the description is minimally complete. It covers the basic operation but lacks context on return values, error cases, or MongoDB-specific nuances. Annotations help by indicating mutation without destruction, but more behavioral detail would improve completeness.

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

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

Schema description coverage is 100%, so the schema fully documents parameters. The description adds minimal value by referencing MongoDB syntax for 'documents', but doesn't explain parameter interactions or provide examples. Baseline 3 is appropriate as the schema carries the 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?

The description clearly states the action ('Insert') and target ('an array of documents into a MongoDB collection'), providing a specific verb+resource combination. However, it doesn't explicitly differentiate from sibling tools like 'insert' (if present) or 'update-many', though the 'many' in the name implies bulk insertion.

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 (e.g., database/collection existence), compare to other insertion methods, or specify use cases like bulk data loading versus single-document insertion with other tools.

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

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

Annotations already declare readOnlyHint=true and destructiveHint=false, so the agent knows this is a safe read operation. The description adds context by specifying it lists 'all collections' for a database, which clarifies scope. However, it doesn't describe behavioral traits like pagination, rate limits, or what happens if the database doesn't exist. With annotations covering safety, a 3 is appropriate as the description adds some value but not rich behavioral context.

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

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

The description is a single, efficient sentence that front-loads the core action ('List all collections') and specifies the context ('for a given database'). There is zero waste or redundancy, making it highly concise and well-structured for quick understanding.

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 (one parameter, read-only per annotations) and no output schema, the description is minimally adequate. It states what the tool does but lacks details on return values (e.g., format of the list) or error conditions. With annotations covering safety, it's complete enough for basic use but could be more informative for an agent.

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

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

Schema description coverage is 100%, with the single parameter 'database' documented as 'Database name'. The description adds no additional meaning beyond this, such as format examples or constraints. Since the schema fully describes the parameter, the baseline is 3 even without extra param info in the description.

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

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

The description clearly states the verb 'list' and the resource 'collections', specifying it's for a given database. It distinguishes from sibling tools like 'list-databases' which lists databases rather than collections. However, it doesn't explicitly differentiate from tools like 'collection-indexes' or 'collection-schema' that also operate on collections, so it's not a perfect 5.

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

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

The description provides no guidance on when to use this tool versus alternatives. It doesn't mention prerequisites (e.g., needing an existing database), exclusions, or compare to siblings like 'list-databases' (which might be a precursor) or 'collection-storage-size' (which provides different collection data). Usage is implied but not explicitly 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 readOnlyHint=true and destructiveHint=false, so the agent knows this is a safe read operation. The description adds minimal context beyond this, as it doesn't detail output format, pagination, or connection requirements. With annotations covering safety, a baseline 3 is appropriate for the limited added value.

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

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

The description is a single, efficient sentence that directly states the tool's purpose with no unnecessary words. It's front-loaded and perfectly sized for its simple function.

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

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

For a simple read-only tool with no parameters and good annotations, the description is adequate but lacks output details (no output schema provided) and doesn't address connection context or sibling differentiation. It meets minimum viability but has clear gaps in completeness.

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

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

There are zero parameters, and schema description coverage is 100%, so the schema fully documents the input (none). The description doesn't need to add parameter details, earning a high baseline score for a parameterless tool.

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

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

The description clearly states the action ('List') and resource ('all databases for a MongoDB connection'), making the purpose immediately understandable. However, it doesn't explicitly differentiate from sibling tools like 'list-collections' or 'db-stats', which prevents a perfect 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?

The description provides no guidance on when to use this tool versus alternatives. It doesn't mention prerequisites (e.g., requiring a connection first), compare to similar tools like 'list-collections', or specify use cases (e.g., for inventory vs. detailed stats).

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 and destructiveHint=false, so the agent knows this is a safe read operation. The description adds that it returns 'most recent' events, which hints at recency but doesn't specify time windows or ordering. It lacks details on rate limits, authentication needs, or output format (e.g., structured vs. raw logs). With annotations covering safety, the description adds minimal but not rich behavioral context.

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

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

The description is a single, efficient sentence: 'Returns the most recent logged mongod events.' It's front-loaded with the core purpose, has zero wasted words, and is appropriately sized for a simple tool. Every part of the sentence earns its place by specifying action, resource, and a key constraint.

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 output schema, simple annotations), the description is somewhat complete but has gaps. It covers the basic purpose but lacks usage guidelines and detailed behavioral context. With annotations handling safety, the description is adequate but not fully helpful for an agent to understand when and how to use it effectively in context with siblings.

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 clear documentation for both parameters (type and limit), including enums and defaults. The description doesn't add any parameter-specific information beyond what the schema provides. According to the rules, when schema coverage is high (>80%), the baseline is 3 even with no param info in the description, which applies here.

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

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

The description clearly states the tool's purpose: 'Returns the most recent logged mongod events.' It specifies the verb ('returns') and resource ('logged mongod events'), and the qualifier 'most recent' adds useful context. However, it doesn't explicitly differentiate from sibling tools like 'atlas-list-alerts' or 'atlas-get-performance-advisor', which might also return log-like data, so it falls short of a perfect 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?

The description provides no guidance on when to use this tool versus alternatives. It doesn't mention sibling tools, prerequisites, or specific contexts (e.g., debugging vs. monitoring). The agent must infer usage from the tool name and description alone, which is insufficient for clear decision-making.

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 indicate this is a non-read-only, non-destructive operation (readOnlyHint: false, destructiveHint: false), which the description doesn't contradict. However, the description adds minimal behavioral context beyond this—it doesn't explain potential side effects (e.g., impact on indexes or queries), authentication needs, or error conditions. With annotations covering basic safety, the description meets a low bar but lacks depth.

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

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

The description is a single, efficient sentence that front-loads the core purpose without unnecessary words. It earns its place by clearly stating what the tool does, making it easy for an agent to parse quickly. There's no wasted verbiage or structural issues.

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 moderate complexity (renaming with a drop option), 100% schema coverage, and annotations providing basic safety hints, the description is minimally adequate. However, without an output schema, it doesn't explain return values or errors, and it lacks context on behavioral nuances (e.g., what 'dropTarget' entails in practice). It meets the minimum but leaves gaps for an agent to navigate.

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 clear parameter documentation in the schema itself (e.g., 'database', 'collection', 'newName', 'dropTarget'). The description adds no additional meaning about parameters beyond implying the tool operates on collections in MongoDB. Since the schema does the heavy lifting, the baseline score of 3 is appropriate.

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

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

The description clearly states the action ('renames') and resource ('a collection in a MongoDB database'), making the purpose immediately understandable. It distinguishes itself from siblings like 'create-collection' or 'drop-collection' by focusing on renaming, but doesn't explicitly contrast with all potential alternatives like modifying collection properties.

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 (e.g., needing an existing collection), exclusions (e.g., when not to rename), or compare with similar tools like 'update-many' for metadata changes. The agent must infer usage from the tool name 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?

Annotations indicate readOnlyHint=false and destructiveHint=false, confirming this is a write operation that isn't destructive. The description adds context by specifying it updates 'all documents that match the specified filter', implying bulk modification, but doesn't disclose further behavioral traits like atomicity, performance impact, or error handling. No contradiction with annotations exists.

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 efficiently conveys the core functionality without unnecessary words. It is front-loaded with the key action and scope, making it easy to parse and understand quickly, with zero wasted information.

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

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

Given the tool's complexity (5 parameters, nested objects, no output schema) and annotations covering safety, the description is adequate but minimal. It lacks details on return values, error cases, or interaction with siblings, leaving gaps for an agent to fully understand the tool's behavior in context, though annotations help mitigate some risks.

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 all parameters well-documented in the schema (e.g., filter syntax, update operators, upsert behavior). The description adds minimal value beyond the schema, only implying bulk updates via 'all documents', which is redundant with the tool name. Baseline 3 is appropriate as the schema carries the semantic 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?

The description clearly states the verb 'Updates' and the resource 'all documents that match the specified filter for a collection', which is specific and actionable. It distinguishes from siblings like 'update-one' (implied by 'many') but doesn't explicitly differentiate from other write operations like 'insert-many' or 'delete-many' beyond the verb, keeping it from a perfect 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?

The description provides no guidance on when to use this tool versus alternatives such as 'update-one' (if available) or other write operations like 'insert-many' or 'delete-many'. It lacks context on prerequisites, error conditions, or typical use cases, offering only a basic functional statement without usage context.

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