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

No annotations are provided, so the description carries full burden. It states 'Create a new Database,' implying a write operation, but doesn't disclose behavioral traits such as permissions required, whether this is idempotent, error handling, or what happens on success/failure. This is a significant gap for a mutation tool with zero annotation coverage.

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 ('Create a new Database.') that is front-loaded and wastes no words. However, it is arguably too concise for a tool with no annotations and complex siblings, potentially under-specifying rather than being efficiently informative.

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 (mutation tool with no annotations, no output schema, and many siblings), the description is incomplete. It doesn't explain what a 'Database' entails in this context, how it relates to other tools, or what to expect after creation. This leaves gaps for an agent to understand the tool's role and behavior 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%, so the schema already documents all three parameters (database_id, name, enabled) thoroughly. The description adds no additional meaning beyond the schema, such as explaining relationships between parameters or providing examples. 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 states the action ('Create') and resource ('a new Database'), which is clear but basic. It doesn't differentiate from siblings like 'databases_create_collection' or 'databases_create_document', making it vague about what specific type of database entity is being created. The purpose is understandable but lacks specificity compared to other tools in the set.

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

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

No guidance is provided on when to use this tool versus alternatives. With many sibling tools for creating different database components (e.g., attributes, collections, documents), the description offers no context on prerequisites, dependencies, or distinctions, leaving the agent to 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?

No annotations are provided, so the description carries full burden for behavioral disclosure. 'Create a boolean attribute' implies a write/mutation operation, but it doesn't disclose any behavioral traits: no information about permissions needed, whether this is idempotent, what happens on conflicts, rate limits, or what the tool returns. For a mutation tool with zero annotation coverage, this is a significant gap in 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 at just three words. While it may be too brief for completeness, as a standalone statement it's front-loaded and wastes no words. Every word earns its place by stating the core action and resource type 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 this is a mutation tool with 6 parameters, no annotations, and no output schema, the description is incomplete. It doesn't explain what happens after creation, what errors might occur, or provide any context about the boolean attribute's behavior in the database system. The description should do more to compensate for the lack of structured metadata.

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 description coverage is 100%, with all 6 parameters clearly documented in the input schema. The description adds no parameter information beyond what's already in the schema. According to scoring 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 'Create a boolean attribute' clearly states the action (create) and resource (boolean attribute), but it's vague about the context. It doesn't specify that this creates an attribute within a specific database collection, which is important for distinguishing it from other attribute creation tools like databases_create_string_attribute or databases_create_integer_attribute. The purpose is understandable but lacks specificity about the parent resources.

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. With many sibling tools like databases_create_string_attribute, databases_create_integer_attribute, etc., there's no indication that this is specifically for boolean data types. The input schema mentions collection creation via another tool, but the description itself offers no usage context, prerequisites, or comparisons to other attribute creation methods.

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

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

With no annotations provided, the description carries full burden for behavioral disclosure. It mentions the prerequisite of creating a database first, which is useful context, but doesn't address critical behavioral aspects like whether this is a mutating operation (implied by 'Create'), what permissions are needed, error conditions, or what happens on success/failure. For a creation tool with zero annotation coverage, this leaves significant 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 appropriately concise with two sentences that both provide value. The first sentence states the purpose clearly, and the second provides important prerequisite information. There's no wasted text, though it could be slightly more structured with explicit separation of purpose and 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?

For a creation tool with 6 parameters, no annotations, and no output schema, the description is insufficient. It provides basic purpose and a prerequisite but lacks crucial information about what the tool returns, error handling, authentication requirements, and behavioral constraints. The agent would need to guess about the outcome of the 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%, so the schema already documents all 6 parameters thoroughly. The description adds no additional parameter information beyond what's in the schema. According to scoring rules, when schema coverage is high (>80%), the baseline is 3 even with no 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 action ('Create a new Collection') and identifies the resource, making the purpose immediately understandable. It doesn't explicitly differentiate from sibling tools like 'databases_create' or 'databases_update_collection', but the verb 'Create' distinguishes it from update/delete 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 important prerequisite guidance ('Before using this route, you should create a new database resource'), which helps the agent understand sequencing requirements. However, it doesn't specify when to use this tool versus alternatives like 'databases_update_collection' or clarify its relationship to sibling attribute creation 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?

No annotations are provided, so the description carries the full burden. It states 'Create' which implies a write/mutation operation, but doesn't disclose behavioral traits like required permissions, whether it's idempotent, error conditions, or what happens on success/failure. The ISO 8601 standard mention is useful but insufficient for a mutation tool with no annotation coverage.

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 waste. It's front-loaded with the core action and key constraint, making it easy to parse quickly. Every word earns its place without 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 mutation tool with 6 parameters, no annotations, and no output schema, the description is incomplete. It lacks crucial context such as what the tool returns, error handling, permissions needed, or how it interacts with other tools (e.g., that 'collection_id' must reference an existing collection created via another tool). The ISO 8601 mention is helpful but doesn't compensate for these gaps.

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

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

The schema description coverage is 100%, so the schema fully documents all 6 parameters. The description adds minimal value beyond the schema by mentioning the ISO 8601 standard, which relates to the 'default' parameter format but doesn't provide additional semantic context for parameters like 'database_id' or 'collection_id'. 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 action ('Create') and resource ('date time attribute') with the specific constraint 'according to the ISO 8601 standard.' It distinguishes this from other attribute creation tools (like boolean, email, etc.) by specifying the attribute type. However, it doesn't explicitly differentiate from its sibling 'databases_update_datetime_attribute' or other datetime-related tools.

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

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

The description provides no guidance on when to use this tool versus alternatives. It doesn't mention prerequisites (e.g., needing an existing database and collection), when not to use it, or how it differs from similar tools like 'databases_update_datetime_attribute' or other attribute creation tools in the sibling list.

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

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

With no annotations provided, the description carries the full burden of behavioral disclosure. While it mentions a prerequisite (collection creation), it doesn't describe important behavioral aspects such as: whether this is a write operation (implied but not stated), what permissions are needed, whether it's idempotent, what happens on duplicate document_id, error conditions, or what the response looks like. For a creation tool with zero annotation coverage, this leaves significant gaps in understanding how the tool behaves.

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 appropriately concise with two sentences that each serve a purpose: the first states the core function, the second provides important prerequisite information. It's front-loaded with the main action and avoids unnecessary verbosity. However, it could be slightly more structured by explicitly separating the tool's purpose from its prerequisites.

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 this is a creation tool with no annotations and no output schema, the description is incomplete. It doesn't explain what happens after creation (success response, error handling), doesn't clarify behavioral aspects like idempotency or permissions, and doesn't differentiate from similar sibling tools. For a tool that creates database documents, more contextual information about the operation's behavior and outcomes is needed.

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, providing detailed documentation for all 5 parameters. The description adds no additional parameter information beyond what's already in the schema. According to the scoring rules, when schema_description_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 action ('Create a new Document') and identifies the resource ('Document'), which is specific and unambiguous. However, it doesn't explicitly differentiate from sibling tools like 'databases_create_documents' (plural) or 'databases_upsert_document', which could cause confusion about when to use this specific tool versus alternatives.

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

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

The description provides some contextual guidance by mentioning prerequisites ('Before using this route, you should create a new collection resource'), which helps establish when this tool is appropriate. However, it doesn't explicitly state when to use this tool versus similar siblings like 'databases_create_documents' or 'databases_upsert_document', nor does it provide clear exclusion criteria or alternative recommendations.

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

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

No annotations are provided, so the description carries full burden. It only discloses the experimental nature and potential breaking changes. It doesn't describe what the tool actually does (creates multiple documents), what permissions are required, whether it's idempotent, what happens on partial failures, or what the response looks like. The warning is useful but insufficient for behavioral understanding.

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 appropriately concise - a single sentence warning about experimental status. It's front-loaded with the most important information (the warning). However, it's under-specified rather than truly concise, as it omits the tool's actual 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?

For a tool that creates multiple documents (a write operation) with no annotations and no output schema, the description is severely incomplete. It doesn't explain what the tool does, what it returns, error conditions, or usage context. The experimental warning is valuable but doesn't compensate for missing core functionality 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 description coverage is 100%, so the schema already documents all three parameters thoroughly. The description adds no additional parameter information beyond what's in the schema. The baseline of 3 is appropriate when the schema does all the parameter documentation 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 is tautological - it restates the tool name ('This endpoint') without specifying what the tool actually does. It mentions it's experimental but doesn't state that this tool creates documents in a database collection. The name 'databases_create_documents' implies document creation, but the description fails to explicitly state this purpose.

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 a warning about experimental status but gives no guidance on when to use this tool versus alternatives. With sibling tools like 'databases_create_document' (singular) and 'databases_create_collection', there's no indication of when batch document creation is appropriate versus single document creation or collection setup.

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

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

No annotations are provided, so the description carries full burden. 'Create' implies a write/mutation operation, but the description doesn't disclose any behavioral traits: no mention of permissions required, whether this is idempotent, what happens on conflict (e.g., if attribute key already exists), rate limits, or what the response contains. For a mutation tool with zero annotation coverage, 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 extremely concise - a single sentence with no wasted words. It's front-loaded with the essential action and resource. While it may be too brief for completeness, it earns full marks for 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?

Given this is a mutation tool with no annotations and no output schema, the description is inadequate. It doesn't explain what an email attribute is, when to use it, what permissions are needed, what the response looks like, or how it differs from other attribute types. For a tool with 6 parameters and complex sibling relationships, this minimal description leaves too many gaps.

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

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

Schema description coverage is 100%, so the schema already documents all 6 parameters thoroughly. The description adds no additional parameter information beyond what's in the schema. According to scoring rules, when schema coverage is high (>80%), the baseline is 3 even with no 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 states the action ('Create') and resource ('an email attribute'), which provides basic purpose. However, it doesn't differentiate this from other attribute creation tools (e.g., databases_create_string_attribute, databases_create_boolean_attribute) beyond the 'email' qualifier in the name. The description doesn't explain what an 'email attribute' is or how it differs from other attribute types.

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. With multiple sibling tools for creating different attribute types (email, string, boolean, integer, etc.), the description offers no context about when an email attribute is appropriate versus other attribute types. There's no mention of prerequisites or when-not-to-use scenarios.

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

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

With no annotations provided, the description carries the full burden of behavioral disclosure. It only mentions that 'elements' acts as a white-list, which is useful but insufficient. It fails to describe critical behaviors such as whether this is a mutating operation (implied by 'Create' but not explicit), permission requirements, error conditions, or what happens upon success (e.g., returns an attribute ID). For a creation tool with zero annotation coverage, 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 extremely concise—just two sentences—with zero wasted words. It front-loads the core purpose and efficiently clarifies a key parameter. Every sentence earns its place, making it easy for an agent 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?

Given the tool's complexity (creating a database attribute with 7 parameters), lack of annotations, and no output schema, the description is incomplete. It doesn't cover behavioral aspects like mutation effects, permissions, or return values, and offers minimal parameter guidance beyond the schema. For a creation tool in a database context, this leaves too many unknowns for effective agent 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 description adds minimal value beyond the input schema, which has 100% coverage. It explains that 'elements' acts as a white-list, providing context not in the schema description, but doesn't elaborate on other parameters like 'key', 'required', or 'array'. Given the high schema coverage, the baseline is 3, and the description meets this by adding some semantic insight for one parameter.

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

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

The description clearly states the action ('Create an enumeration attribute') and identifies the resource ('enumeration attribute'), which is specific and unambiguous. However, it doesn't explicitly differentiate this tool from its sibling 'databases_update_enum_attribute' or other attribute creation tools like 'databases_create_string_attribute', missing an opportunity for full sibling 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 no guidance on when to use this tool versus alternatives. It doesn't mention prerequisites (e.g., needing an existing database and collection), compare it to other attribute creation tools, or indicate when to choose an enum attribute over other types. This leaves the agent without context for tool selection.

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

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

With no annotations provided, the description carries full burden for behavioral disclosure. It states this is a creation operation but doesn't mention permission requirements, whether this is a destructive operation (modifies database schema), rate limits, or what happens on success/failure. The description is minimal and leaves critical behavioral aspects unspecified.

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 just two sentences that directly state the purpose and mention optional parameters. Every word serves a purpose with zero redundancy or 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 database schema mutation tool with 8 parameters, no annotations, and no output schema, the description is insufficient. It doesn't explain the relationship between attributes and collections/documents, doesn't mention error conditions, and provides no information about what the tool returns. The minimal description leaves too many contextual gaps for effective tool 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?

With 100% schema description coverage, the schema already documents all 8 parameters thoroughly. The description adds minimal value by mentioning 'minimum and maximum values can be provided' which corresponds to the 'min' and 'max' parameters, but doesn't provide additional context beyond what's in the schema descriptions. This 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 ('Create a float attribute') and resource type, which distinguishes it from other attribute creation tools like boolean or string attributes. However, it doesn't explicitly differentiate from sibling tools like 'databases_create_float_attribute' vs 'databases_update_float_attribute' or explain the broader context of what an attribute is within Appwrite's database system.

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 creating other attribute types (boolean, string, etc.) or when to use the update version instead. It mentions optional parameters but doesn't explain use cases for those options or prerequisites for using this tool.

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

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

No annotations are provided, so the description carries the full burden of behavioral disclosure. It states the tool 'creates an index,' implying a write operation, but doesn't cover critical aspects like permissions required, whether the operation is idempotent, potential performance impacts, error conditions, or what happens on success/failure. The design tip about attributes is helpful but insufficient for a mutation 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 a single sentence that directly states the tool's purpose, followed by a design recommendation. It's front-loaded and wastes no words, though the second part could be more tightly integrated. Overall, it's efficient and well-structured for its length.

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 mutation tool with 7 parameters, no annotations, and no output schema, the description is incomplete. It lacks information on behavioral traits (e.g., side effects, error handling), usage context, and output expectations. The schema handles parameter documentation well, but the description doesn't compensate for the missing behavioral and contextual details.

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

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

Schema description coverage is 100%, so the schema already documents all 7 parameters thoroughly. The description adds minimal value beyond the schema—it implies that 'attributes' should be comprehensive for querying, but doesn't explain parameter interactions or provide examples. With high schema coverage, 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 ('creates an index') and the target ('on the attributes listed'), which is specific and unambiguous. It distinguishes this tool from sibling tools like databases_create_collection or databases_create_document by focusing on index creation. However, it doesn't explicitly differentiate from databases_create_attribute tools, which is a minor gap.

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 mentions including 'all the attributes you will query in a single request,' but this is a design tip rather than usage context. There's no mention of prerequisites (e.g., needing an existing collection), when to choose this over other indexing methods, or exclusions.

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

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

With no annotations provided, the description carries full burden for behavioral disclosure. It mentions optional min/max values but fails to describe critical behaviors: whether this is a mutating operation (likely yes, given 'create'), what permissions are required, how errors are handled, or what the response contains. For a creation tool with 8 parameters, this leaves significant gaps in understanding how the tool behaves.

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—just two sentences that directly state the tool's function and one optional feature. Every word earns its place with zero redundancy or unnecessary elaboration, 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?

Given the complexity (8 parameters, creation operation) and lack of both annotations and output schema, the description is insufficient. It doesn't explain what happens after creation, error conditions, relationships to other tools, or behavioral expectations. For a tool that modifies database schema, more context about side effects and outcomes is needed.

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 8 parameters. The description adds minimal value by mentioning min/max values as optional, which is already clear from the schema (where they're not in required array). No additional parameter semantics are provided beyond what the schema already states, meeting 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 ('Create an integer attribute') and resource ('integer attribute'), making the purpose immediately understandable. However, it doesn't explicitly differentiate from sibling tools like 'databases_create_float_attribute' or 'databases_create_string_attribute' beyond mentioning 'integer' in the name, which is why it doesn't achieve 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 (like needing a database and collection), compare it to other attribute creation tools, or indicate when integer attributes are appropriate versus other data types. 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?

With no annotations provided, the description carries full burden for behavioral disclosure. 'Create IP address attribute' implies a mutation/write operation, but the description doesn't address permissions needed, whether this operation is reversible/destructive, rate limits, or what happens on success/failure. For a creation tool with zero annotation coverage, this is a significant gap in 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 maximally concise - a single sentence with zero wasted words. It's front-loaded with the essential action and resource. Every word earns its place, though this conciseness comes at the expense of completeness.

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 creation/mutation tool with 6 parameters, no annotations, and no output schema, the description is inadequate. It doesn't address behavioral aspects (permissions, side effects), provide usage guidance relative to siblings, or explain what constitutes success/failure. The 100% schema coverage helps with parameters, but the overall context for using this tool remains incomplete.

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

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

Schema description coverage is 100%, so the schema already documents all 6 parameters thoroughly. The description adds no additional parameter semantics beyond what's in the schema - it doesn't explain relationships between parameters (like 'default' cannot be set when 'required' is true, though the schema mentions this), format expectations, or usage patterns. 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 'Create IP address attribute' clearly states the verb ('Create') and resource ('IP address attribute'), making the purpose immediately understandable. However, it doesn't differentiate this tool from its many sibling attribute creation tools (e.g., databases_create_boolean_attribute, databases_create_string_attribute), which all follow the same pattern but for different data types.

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 specific tool versus alternatives. While the context suggests this is for creating IP address attributes specifically, there's no mention of when IP attributes are appropriate compared to other attribute types, nor any prerequisites or constraints beyond what's implied by 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?

No annotations are provided, so the description carries the full burden. It mentions 'Create' implying a write operation but doesn't disclose behavioral traits like whether this is idempotent, requires specific permissions, or has side effects (e.g., impact on existing data). The link offers more info but isn't integrated into the description.

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 brief and to the point with a single sentence and a helpful link. However, it could be more front-loaded with key details instead of relying on external documentation. No wasted words, but slightly under-specified.

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 of creating a relationship attribute with 8 parameters and no annotations or output schema, the description is insufficient. It doesn't explain what a relationship attribute is, how it behaves, or what the tool returns, leaving significant gaps for an AI agent to understand its 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 100%, so the schema already documents all 8 parameters with descriptions. The description adds no additional meaning about parameters beyond what the schema provides, such as explaining 'type' options or 'on_delete' constraints. Baseline is 3 due to 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 states the action ('Create relationship attribute') which is clear but vague. It doesn't specify what a relationship attribute is or how it differs from other attribute types (like boolean, string, etc.) among the sibling tools. The link provides additional context but isn't part of the description itself.

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 like 'databases_update_relationship_attribute' or other attribute creation tools. The description lacks context about prerequisites, such as needing existing collections or databases, which are implied by the parameters but not 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?

No annotations are provided, so the description carries the full burden of behavioral disclosure. 'Create a string attribute' implies a write/mutation operation but reveals nothing about permissions required, whether this operation is reversible, potential side effects on existing data, rate limits, or what happens on success/failure. For a tool that modifies database schema with 8 parameters, this is critically insufficient.

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 maximally concise at just three words. While this conciseness comes at the expense of helpful information, every word earns its place by communicating the core action. There's no wasted verbiage or 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 complexity of database schema modification (8 parameters, 5 required), absence of annotations, and lack of output schema, the description is woefully incomplete. It doesn't explain what constitutes a successful creation, what gets returned, error conditions, or how this operation fits into broader database workflows. The description fails to provide the contextual understanding needed for safe and effective tool 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 description coverage is 100%, with all 8 parameters well-documented in the input schema. The description adds no additional parameter information beyond what's already in the structured schema. According to scoring rules, when schema coverage is high (>80%), the baseline is 3 even with no parameter information 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 'Create a string attribute' is a tautology that restates the tool name without adding meaningful context. It specifies the verb ('Create') and resource ('string attribute'), but fails to distinguish this tool from sibling tools like 'databases_create_boolean_attribute' or 'databases_create_email_attribute' beyond the attribute type. A more helpful description would clarify what a 'string attribute' represents in this database system.

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. With numerous sibling tools for creating different attribute types (boolean, datetime, email, etc.), there's no indication of when a string attribute is appropriate versus other data types. It also doesn't mention prerequisites like needing an existing database and collection, or relationships to other tools in the system.

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. 'Create a URL attribute' implies a write/mutation operation but reveals nothing about permissions required, whether this is reversible, what happens on failure, rate limits, or what the tool returns. For a mutation tool with zero annotation coverage, this description provides almost no behavioral context beyond the basic action implied by 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 maximally concise at just three words. While this represents under-specification rather than ideal conciseness, within the scoring framework for this dimension, it earns full points for having zero wasted words and being front-loaded with the core action. Every word ('Create', 'URL', 'attribute') contributes directly to the minimal purpose statement.

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

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

Given this is a mutation tool with 6 parameters, no annotations, and no output schema, the description is severely incomplete. It doesn't explain what a URL attribute is, when to use it, what permissions are needed, what happens on success/failure, or how it relates to other database operations. The agent would struggle to use this tool correctly without significant external knowledge about URL attributes in database systems.

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 description adds no parameter information beyond what's already in the schema. However, with 100% schema description coverage where all 6 parameters have clear descriptions, the baseline score is 3. The schema adequately documents database_id, collection_id, key, required, default, and array parameters, so the description doesn't need to compensate for schema gaps but also adds no 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 'Create a URL attribute' is essentially a tautology that restates the tool name 'databases_create_url_attribute'. While it indicates the verb 'create' and resource 'URL attribute', it doesn't specify what a URL attribute is or how it differs from other attribute types like string or email attributes. Compared to siblings like 'databases_create_boolean_attribute' or 'databases_create_email_attribute', this description provides no meaningful 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?

The description provides absolutely no guidance on when to use this tool versus alternatives. It doesn't mention when URL attributes are appropriate versus other attribute types, what prerequisites exist (like needing a database and collection first), or how this relates to sibling tools like 'databases_create_string_attribute' or 'databases_update_url_attribute'. The agent receives no contextual usage information.

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

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

With no annotations provided, the description carries the full burden of behavioral disclosure. It mentions the decrement action but fails to describe critical behaviors: whether this is a mutation (implied but not stated), potential side effects, error handling (e.g., for non-numeric attributes), or response format. This leaves significant gaps for a tool that modifies data.

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, making it easy to parse quickly. Every part of the sentence contributes essential 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 (6 parameters, mutation operation) and lack of annotations and output schema, the description is insufficient. It does not address behavioral aspects like error conditions, return values, or interaction with sibling tools, leaving the agent with incomplete context for safe and effective 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 100%, providing clear documentation for all parameters. The description adds no additional semantic context beyond the schema, such as examples or constraints not covered (e.g., attribute must be numeric). This meets the baseline for high schema coverage but does not 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 action ('Decrement') and target ('a specific attribute of a document'), making the purpose understandable. However, it does not explicitly differentiate this tool from its sibling 'databases_increment_document_attribute', which performs a similar but opposite operation, missing an opportunity for clear 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 no guidance on when to use this tool versus alternatives, such as 'databases_increment_document_attribute' or general update tools like 'databases_update_document'. It lacks context about prerequisites, error conditions, or typical use cases, leaving the agent with minimal usage direction.

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

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

With no annotations provided, the description carries the full burden of behavioral disclosure. It correctly identifies this as a destructive operation ('Delete') and specifies permission requirements. However, it doesn't describe what happens after deletion (irreversible? cascading effects?), rate limits, or error conditions. For a destructive tool with zero annotation coverage, this 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 perfectly concise with two sentences that each earn their place: the first states the core functionality, the second adds crucial permission context. No wasted words, well-structured, and front-loaded with the primary 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?

For a destructive deletion tool with no annotations and no output schema, the description provides basic purpose and permission context but lacks important behavioral details (irreversibility, effects on related data, response format). Given the high-stakes nature of database deletion and the rich sibling tool ecosystem, more completeness 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?

Schema description coverage is 100%, so the schema already documents the single 'database_id' parameter. The description adds no additional parameter semantics beyond what's in the schema (it mentions 'unique ID' but the schema already says 'Database ID'). With complete schema coverage, the baseline score of 3 is appropriate as the description doesn't 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 specific action ('Delete') and target resource ('a database by its unique ID'), distinguishing it from sibling tools like databases_delete_document or databases_delete_collection. It precisely identifies what the tool does without being vague or tautological.

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 when to use the tool (deleting a database by ID) and includes an important prerequisite (API keys with databases.write scope). However, it doesn't explicitly mention when NOT to use it or name specific alternatives among the many sibling deletion tools (e.g., databases_delete_document vs. databases_delete).

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

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

No annotations are provided, so the description carries full burden for behavioral disclosure. It only states 'deletes an attribute' without mentioning critical aspects like permissions required, whether the deletion is reversible, side effects on related data, or error conditions. This is inadequate for a destructive operation with zero annotation coverage.

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 with no wasted words. It is front-loaded with the core action, making it easy to parse quickly, though this brevity contributes to gaps 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?

Given the complexity of a destructive database operation, no annotations, and no output schema, the description is incomplete. It fails to address behavioral risks, expected outcomes, or error handling, leaving the agent under-informed about critical usage aspects.

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_id, collection_id, and key. The description adds no additional meaning beyond the schema, such as explaining relationships between parameters or usage examples. Baseline 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 states the action ('deletes') and resource ('an attribute'), which clarifies the basic purpose. However, it doesn't specify what type of attribute (e.g., database attribute vs. document attribute) or distinguish it from sibling tools like 'databases_delete' or 'databases_delete_document', leaving ambiguity about scope.

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. With many sibling tools for deleting various database components (e.g., databases_delete, databases_delete_collection, databases_delete_document), the description lacks context on prerequisites, dependencies, or appropriate scenarios, offering no help in 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?

No annotations are provided, so the description carries the full burden of behavioral disclosure. It mentions the permission requirement ('write permissions'), which is useful, but lacks details on critical behavioral traits: it does not specify whether the deletion is irreversible, what happens to associated data (e.g., documents in the collection), error handling, or rate limits. For a destructive operation with no annotation coverage, 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 appropriately sized with two concise sentences that front-load the core action and follow with permission context. There is no wasted verbiage, and each sentence adds value, though it could be slightly more structured (e.g., separating usage notes).

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 as a destructive delete operation, no annotations, and no output schema, the description is incomplete. It lacks information on behavioral consequences (e.g., permanence, cascading effects), error responses, or return values, which are crucial for safe and effective use by an AI 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 both parameters (database_id and collection_id) documented in the schema. The description does not add any meaning beyond the schema, such as explaining the format or source of IDs, but since the schema fully covers the parameters, 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 specific action ('Delete') and target resource ('a collection by its unique ID'), distinguishing it from sibling tools like databases_delete, databases_delete_document, or databases_delete_attribute. It precisely identifies what the tool does without being vague or tautological.

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 specifying that 'Only users with write permissions have access to delete this resource,' which helps determine when to use it based on user permissions. However, it does not explicitly state when not to use it or name alternative tools for similar operations, such as databases_delete for deleting databases instead of collections.

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

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

No annotations are provided, so the description carries full burden. 'Delete' implies a destructive mutation, but the description doesn't disclose whether this operation is permanent, requires specific permissions, has rate limits, or what happens on success/failure. For a destructive tool with zero annotation coverage, this is a significant behavioral information gap.

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

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

The description is a single, efficient sentence that gets straight to the point with zero wasted words. It's appropriately sized for a simple delete operation and front-loads the essential information. Every word earns its place.

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

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

For a destructive mutation tool with no annotations and no output schema, the description is insufficiently complete. It doesn't address critical context like permissions needed, whether deletion is permanent/reversible, error conditions, or what the response contains. The agent lacks necessary information to use this tool safely and effectively despite the clear schema.

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

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

Schema description coverage is 100%, so the schema already documents all three parameters (database_id, collection_id, document_id) with basic descriptions. The description adds no additional parameter semantics beyond what's in the schema - it doesn't explain relationships between parameters, format requirements, or provide examples. With complete schema coverage, the baseline 3 is appropriate.

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

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

The description clearly states the action ('Delete') and resource ('a document by its unique ID'), making the purpose immediately understandable. However, it doesn't differentiate this tool from its sibling 'databases_delete_documents' (plural), which appears to handle bulk deletion. The description is specific but lacks sibling 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 no guidance on when to use this tool versus alternatives. It doesn't mention prerequisites (e.g., needing database/collection/document IDs), compare it to 'databases_delete_documents' for bulk operations, or indicate when deletion is appropriate versus updating. Without any usage context, the agent must infer everything from the tool name and 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?

No annotations are provided, so the description carries the full burden of behavioral disclosure. It only warns that the feature is experimental and may change, which is useful but insufficient. It does not describe key behaviors: that this is a destructive deletion operation, what happens to deleted documents (e.g., permanent removal), any authentication or permission requirements, rate limits, or the response format. For a mutation tool with zero annotation coverage, 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 concise and front-loaded with a clear warning, using only one sentence. There is no wasted text, and it efficiently communicates the experimental status. However, it under-specifies the tool's purpose, which slightly reduces effectiveness, but the structure itself 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?

Given the complexity of a destructive deletion tool with no annotations and no output schema, the description is incomplete. It lacks essential context: what the tool does, behavioral traits (e.g., destructiveness), usage guidelines, and output expectations. The experimental warning is helpful but does not compensate for missing core information, making it inadequate for safe and effective use by an AI 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%, so the schema already documents all three parameters (database_id, collection_id, queries) with details like maximum query limits. The description adds no parameter-specific information beyond what the schema provides, such as explaining how queries work or their impact. With high schema coverage, the baseline score of 3 is appropriate as the description does not compensate but also does not detract.

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 is a tautology that restates the tool name 'databases_delete_documents' without specifying what it actually does. It provides only a warning about the experimental nature of the endpoint, not the verb+resource action (e.g., 'Delete documents from a collection in a database based on queries'). This fails to distinguish it from sibling tools like 'databases_delete_document' (singular).

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 when to use it (e.g., for bulk deletion based on queries) versus other deletion tools like 'databases_delete_document' (singular) or 'databases_delete_collection'. It lacks any context, prerequisites, or exclusions, leaving the agent with no usage direction.

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 full burden but only states the action ('Delete'). It doesn't disclose behavioral traits like whether deletion is permanent, requires specific permissions, has side effects (e.g., affecting query performance), or any rate limits. This is inadequate for a destructive 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 a single, efficient sentence with zero waste. It's appropriately sized and front-loaded, making it easy to parse quickly without unnecessary details.

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 (a destructive delete operation), lack of annotations, and no output schema, the description is incomplete. It fails to cover critical aspects like behavioral transparency, usage guidelines, or expected outcomes, leaving significant gaps 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?

Schema description coverage is 100%, so the schema already documents all parameters (database_id, collection_id, key). The description adds no meaning beyond this, such as explaining relationships between parameters or usage examples, meeting 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 'Delete an index' states a clear verb ('Delete') and resource ('index'), which is better than a tautology. However, it lacks specificity about what type of index (e.g., database index) and doesn't distinguish it from sibling tools like 'databases_delete' or 'databases_delete_attribute', making it vague in context.

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

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

No guidance is provided on when to use this tool versus alternatives. It doesn't mention prerequisites, such as needing an existing index, or compare it to related tools like 'databases_delete' or 'databases_delete_attribute', leaving the agent without context 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. It states the tool 'Get's a database and returns JSON metadata, which implies a read-only operation, but it does not disclose behavioral traits like authentication requirements, error handling, rate limits, or what specific metadata is included. This leaves significant gaps for a tool with no annotation coverage.

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 that are front-loaded and efficient. The first sentence states the purpose, and the second adds context about the response format, with no wasted words or 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?

Given the tool's low complexity (single parameter, no output schema, no annotations), the description is minimally adequate. It covers the basic purpose and response format, but lacks details on behavioral aspects and usage guidelines, which are important for a tool with no annotations. It meets the minimum viable threshold but has clear gaps.

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

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

The input schema has 100% description coverage, with the single parameter 'database_id' documented as 'Database ID.' The description adds no additional meaning beyond this, such as format examples or constraints. With high schema coverage, the baseline score of 3 is appropriate as 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 verb 'Get' and the resource 'database by its unique ID', which is specific and distinguishes it from siblings like databases_list (which lists multiple databases) or databases_get_document (which gets a document within a database). It precisely defines the operation and target.

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 siblings like databases_list for listing databases or databases_get_document for retrieving documents within a database, leaving the agent to infer usage from tool names 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?

No annotations are provided, so the description carries full burden. It only states the action ('Get') without disclosing behavioral traits such as read-only nature, authentication needs, error handling, rate limits, or what happens if the attribute doesn't exist. This is inadequate for a tool with no annotation coverage.

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 waste. It's front-loaded and appropriately sized for the tool's purpose, making it easy to parse 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 no annotations and no output schema, the description is incomplete. It lacks behavioral context, usage guidelines, and details on return values or errors. For a tool with 3 required parameters and no structured output, more information is needed to guide effective 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 100%, with clear parameter descriptions in the input schema. The description adds no meaning beyond the schema, as it doesn't explain parameter relationships, constraints, or usage examples. Baseline 3 is appropriate since 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 'Get attribute by ID' clearly states the verb ('Get') and resource ('attribute'), but it's vague about what an 'attribute' means in this context and doesn't distinguish from sibling tools like 'databases_get' or 'databases_list_attributes'. It specifies retrieval by ID but lacks context about the attribute type or system.

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 sibling tools like 'databases_list_attributes' for listing all attributes or 'databases_get' for database-level info, leaving the agent to infer usage from the name alone without explicit context or exclusions.

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

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

With no annotations, the description carries full burden but only states it returns JSON metadata without detailing behavioral traits. It lacks information on permissions, rate limits, error handling, or whether it's idempotent/safe, which is critical for a read operation in a database 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 appropriately sized with two sentences that are front-loaded and efficient. The first sentence states the core purpose, and the second adds context about the response format, with no wasted 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?

Given the tool's low complexity (2 simple parameters, no output schema, no annotations), the description is minimally adequate but incomplete. It covers the basic action and response type but misses usage context and behavioral details, leaving gaps for an AI agent to infer proper 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%, so the schema fully documents the two required parameters (database_id and collection_id). The description adds no additional meaning beyond implying IDs are 'unique', which is already suggested by the schema. Baseline 3 is appropriate as the schema handles parameter documentation.

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

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

The description clearly states the action ('Get') and resource ('a collection by its unique ID'), making the purpose specific and understandable. However, it doesn't explicitly differentiate from sibling tools like 'databases_get' or 'databases_list_collections', which would require mentioning it's for retrieving a single collection rather than a database or list.

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

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

No guidance is provided on when to use this tool versus alternatives. It doesn't mention prerequisites (e.g., needing a database and collection ID), exclusions, or compare to siblings like 'databases_list_collections' for browsing or 'databases_get' for database metadata.

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

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

With no annotations provided, the description carries the full burden of behavioral disclosure. It mentions the response format ('JSON object with the document data'), which is helpful. However, it lacks critical details like whether this is a read-only operation (implied but not stated), error conditions (e.g., invalid ID), authentication needs, rate limits, or pagination. For a retrieval tool with zero annotation coverage, this is insufficient.

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 waste. The first sentence states the core purpose, and the second adds useful behavioral context about the response format. It's front-loaded and appropriately sized for a simple retrieval tool.

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

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

Given the tool's low complexity (a simple get-by-ID operation), 100% schema coverage, and no output schema, the description is moderately complete. It covers the basic purpose and response format but lacks behavioral details (e.g., error handling, auth) and usage guidelines. For a tool with no annotations, it should do more to compensate, but it's not entirely 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 100%, so the schema fully documents all 4 parameters (database_id, collection_id, document_id, queries). The description adds no additional parameter semantics beyond what's in the schema, such as explaining the relationship between parameters or providing examples. Baseline 3 is appropriate when the 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 verb 'Get' and the resource 'document by its unique ID', making the purpose unambiguous. It distinguishes from siblings like 'databases_list_documents' (list vs get by ID) and 'databases_create_document' (create vs get). However, it doesn't explicitly contrast with all siblings, 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 database/collection IDs), when to use 'databases_list_documents' for multiple documents, or any constraints. 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?

With no annotations provided, the description carries the full burden of behavioral disclosure. 'Get index by ID' implies a read-only operation, but it doesn't specify authentication requirements, rate limits, error handling (e.g., what happens if the index doesn't exist), or the format of the returned data. This leaves significant gaps for an agent to understand how to invoke it safely.

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 at three words, front-loading the core action ('Get index by ID') with zero wasted words. It efficiently communicates the basic purpose without unnecessary elaboration, 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?

Given the complexity of database operations, no annotations, and no output schema, the description is incomplete. It lacks details on authentication, error cases, return format, and how it differs from sibling tools. For a tool with three required parameters and no structured safety hints, more context is needed to guide effective 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 100%, with all three parameters (database_id, collection_id, key) documented in the schema. The description adds no additional meaning beyond implying these IDs are used to locate the index. Since the schema does the heavy lifting, the baseline score of 3 is appropriate, though the description doesn't compensate for any gaps.

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 index by ID' clearly states the action (get) and resource (index), but it's vague about what 'index' refers to in this database context. It distinguishes from siblings like 'databases_list_indexes' by focusing on retrieval of a specific index, but lacks specificity about what an index represents (e.g., database structure for query optimization).

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 prerequisites (e.g., needing an existing index), contrast with 'databases_list_indexes' for listing all indexes, or specify error conditions (e.g., invalid ID). The description alone offers no usage context.

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

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

With no annotations provided, the description carries the full burden of behavioral disclosure. It mentions the increment action but fails to describe key behaviors: whether this is a mutation (implied but not stated), error conditions (e.g., if the attribute doesn't exist or isn't numeric), or side effects. The input schema hints at a 'max' constraint, but the description does not explain this behavioral trait.

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, making it easy to parse and understand quickly. It is appropriately sized for the tool's complexity and front-loads the core action effectively.

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 mutation tool with no annotations and no output schema, the description is incomplete. It does not cover behavioral aspects like error handling, permissions required, or what the tool returns, leaving significant gaps for an AI agent to understand how to use it correctly in 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 the schema fully documents all parameters. The description adds no additional meaning beyond what the schema provides, such as explaining the relationship between parameters or usage examples. Baseline 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 clearly states the action ('increment'), target ('a specific attribute of a document'), and mechanism ('by a given value'), making the purpose immediately understandable. However, it does not explicitly differentiate from its sibling 'databases_decrement_document_attribute', which performs a similar but opposite operation, leaving some ambiguity in sibling 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 no guidance on when to use this tool versus alternatives like 'databases_update_document' or 'databases_decrement_document_attribute'. It lacks context about prerequisites, such as requiring the attribute to exist and be numeric, or when incremental updates are preferred over direct updates.

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

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

No annotations are provided, so the description carries full burden. It mentions filtering via 'search' but lacks critical behavioral details: whether this is a read-only operation, if it requires authentication, pagination behavior, rate limits, or what the output format looks like. For a list tool with zero annotation coverage, 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 two sentences, front-loaded with the core purpose and followed by a brief note on filtering. It's efficient with zero wasted words, though it could be slightly more structured (e.g., separating core functionality from optional features).

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 no annotations, no output schema, and a list operation with potential complexity (e.g., pagination, authentication), the description is incomplete. It covers the basic purpose and hints at filtering but misses behavioral context, return format, and usage distinctions from siblings, leaving gaps for an AI 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%, so the schema already documents both parameters ('queries' and 'search') thoroughly. The description adds minimal value by mentioning the 'search' parameter for filtering, but doesn't explain parameter interactions or provide syntax examples beyond what's in the schema. Baseline 3 is appropriate when 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 action ('Get a list') and resource ('all databases from the current Appwrite project'), making the purpose evident. However, it doesn't explicitly differentiate from sibling tools like 'databases_get' (singular) or 'databases_list_collections', which are related but distinct 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 implies usage for listing databases with optional filtering via the 'search' parameter, but provides no explicit guidance on when to use this versus alternatives like 'databases_get' (for a single database) or other list tools. It mentions filtering but doesn't clarify prerequisites or exclusions.

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

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

No annotations are provided, so the description carries the full burden of behavioral disclosure. It states the tool lists attributes but does not describe key behaviors such as pagination, rate limits, authentication requirements, or the format of returned data. For a read operation with no annotation coverage, this is a significant gap in 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, clear sentence that efficiently states the tool's action. It is front-loaded with the core purpose and avoids unnecessary words. However, it could be slightly more specific (e.g., 'List schema attributes') to improve clarity without losing 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?

Given the complexity of a list operation with filtering via queries, no annotations, and no output schema, the description is incomplete. It does not explain the return format, pagination, error handling, or how the 'queries' parameter works in practice. For a tool with three parameters and behavioral unknowns, more context is needed.

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 input schema fully documents the parameters (database_id, collection_id, queries). The description does not add any meaning beyond what the schema provides, such as explaining the purpose of 'queries' or how they filter attributes. With high schema coverage, 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 states the action ('List') and target ('attributes in the collection'), which clarifies the tool's purpose. However, it lacks specificity about what 'attributes' refer to (e.g., database schema attributes like fields or properties) and does not differentiate from sibling tools like 'databases_list_collections' or 'databases_list_documents', making it somewhat vague.

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 prerequisites, such as needing a database and collection ID, or compare it to related tools like 'databases_get_attribute' for retrieving a single attribute. This leaves the agent without context for appropriate 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?

No annotations are provided, so the description carries the full burden of behavioral disclosure. It mentions filtering via search and queries, but fails to describe key traits such as pagination behavior, rate limits, authentication requirements, error handling, or the format of returned data. For a read operation with no annotation coverage, this leaves significant gaps in understanding how the tool behaves.

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 with two sentences that are front-loaded with the core purpose. There's no wasted text, though it could be slightly more structured by explicitly separating purpose from usage notes. It efficiently conveys the essential information without 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?

Given the complexity of a listing tool with filtering options, no annotations, and no output schema, the description is incomplete. It doesn't address the return format, pagination, error cases, or how the tool integrates with sibling operations. For a tool with three parameters and behavioral nuances, more context is needed to guide effective 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 100%, so the schema already documents all parameters thoroughly. The description adds minimal value by referencing the 'search parameter' and implying filtering, but doesn't provide additional semantics beyond what's in the schema (e.g., explaining how 'queries' interact with 'search'). Baseline 3 is appropriate as 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 verb ('Get a list') and resource ('collections that belong to the provided databaseId'), making the purpose specific and understandable. It distinguishes this as a listing operation rather than creation or deletion, though it doesn't explicitly differentiate from other list operations like 'databases_list' or 'databases_list_documents' 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?

The description implies usage context by mentioning the 'search parameter to filter your results,' suggesting it's for retrieving filtered collections. However, it lacks explicit guidance on when to use this tool versus alternatives like 'databases_get_collection' (for a single collection) or 'databases_list' (for listing databases), and doesn't specify prerequisites or exclusions.

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

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

With no annotations provided, the description carries full burden for behavioral disclosure. It mentions filtering capability but fails to describe important behavioral traits: whether this is a read-only operation, if it requires authentication, pagination behavior, rate limits, or what happens with invalid database/collection IDs. The description is insufficient for a list operation with potential complexity.

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 appropriately concise with two sentences that each serve a purpose: stating the core functionality and mentioning filtering capability. It's front-loaded with the primary purpose. However, it could be slightly more structured by explicitly separating purpose from parameter guidance.

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 list operation with 3 parameters, no annotations, and no output schema, the description is incomplete. It doesn't address authentication requirements, error conditions, pagination, rate limits, or return format. While schema coverage is good for parameters, the overall context for using this tool effectively is lacking.

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

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

Schema description coverage is 100%, so the schema already documents all three parameters thoroughly. The description adds minimal value beyond the schema by mentioning 'query params to filter your results' which aligns with the 'queries' parameter, but doesn't provide additional semantic context or usage examples beyond what's in the schema descriptions.

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

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

The description clearly states the action ('Get a list') and target resources ('all the user's documents in a given collection'), providing specific verb+resource pairing. However, it doesn't explicitly differentiate from sibling tools like 'databases_get_document' (singular) or 'databases_list_collections', missing full sibling 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 mentions using query params to filter results, which implies some usage context, but provides no explicit guidance on when to use this tool versus alternatives like 'databases_get_document' for single documents or 'databases_list_collections' for listing collections instead of documents. No when-not-to-use or prerequisite information is included.

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

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

With no annotations provided, the description carries the full burden of behavioral disclosure. It states the action ('List') but doesn't reveal any behavioral traits: it doesn't mention if this is a read-only operation, whether it requires specific permissions, if there are rate limits, what the output format looks like, or if queries support pagination. For a listing tool with zero annotation coverage, this leaves significant gaps in understanding how the tool behaves.

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 zero wasted words. It's front-loaded with the core action ('List indexes'), making it immediately understandable. Every word earns its place, and there's no redundancy or 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 complexity of a listing operation with querying capabilities and no output schema, the description is incomplete. It doesn't explain what an 'index' is in this context, how results are returned (e.g., pagination, format), or error conditions. With no annotations and an output schema missing, the description should provide more context to help the agent use the tool effectively.

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 description coverage is 100%, so the schema already documents all three parameters thoroughly. The description adds no additional meaning beyond what's in the schema—it doesn't explain parameter interactions, default behaviors, or usage examples. With high schema coverage, the baseline score of 3 is appropriate, as the description doesn't compensate but also doesn't detract.

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 resource ('indexes in the collection'), making the purpose immediately understandable. It distinguishes itself from sibling tools like 'databases_get_index' (which retrieves a single index) and 'databases_delete_index' (which removes an index). However, it doesn't explicitly mention the database context, which is implied but could be more specific.

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

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

The description provides no guidance on when to use this tool versus alternatives. It doesn't mention prerequisites (like needing an existing database and collection), nor does it differentiate from similar listing tools like 'databases_list_attributes' or 'databases_list_documents'. The agent must infer usage from the tool name and schema 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?

No annotations are provided, so the description carries full burden. It states 'Update' which implies mutation, but doesn't disclose behavioral traits like required permissions, whether changes are reversible, side effects (e.g., impact on users or data), rate limits, or error conditions. The description adds no context beyond the basic action.

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

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

The description is a single, efficient sentence with zero waste. It's front-loaded with the core action and resource, making it easy to parse. Every word earns its place without redundancy or fluff.

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 (a mutation tool with no annotations and no output schema), the description is incomplete. It lacks behavioral context (e.g., safety, permissions), doesn't explain what 'update' entails beyond the ID reference, and omits guidance on alternatives or outcomes. For a tool that modifies databases, this leaves significant gaps for an AI 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%, so the schema fully documents all three parameters (database_id, name, enabled) with clear descriptions. The description adds no meaning beyond what the schema provides—it mentions 'by its unique ID' which aligns with 'database_id' but doesn't elaborate on parameter interactions or constraints. Baseline 3 is appropriate when 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 action ('Update') and resource ('a database'), specifying it's done 'by its unique ID'. This distinguishes it from other update operations in the sibling list (like updating attributes, collections, or documents). However, it doesn't explicitly differentiate from other database-level operations like 'databases_get' or 'databases_delete' beyond the verb.

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., needing an existing database ID), contrast with sibling tools like 'databases_create' or 'databases_delete', or specify use cases (e.g., renaming, enabling/disabling). Usage is implied only by the verb 'Update'.

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

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

With no annotations provided, the description carries the full burden of behavioral disclosure. It helpfully notes that 'Changing the `default` value will not update already existing documents,' which is important behavioral context. However, it doesn't address other critical aspects like whether this requires special permissions, what happens on failure, or what the response contains (no output schema).

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

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

The description is perfectly concise - two sentences that each earn their place. The first states the core purpose, the second provides important behavioral context about the 'default' parameter. No wasted words or redundant information.

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

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

For a mutation tool with no annotations and no output schema, the description provides minimal but useful context about the 'default' parameter behavior. However, it doesn't address other important aspects like error conditions, permission requirements, or what constitutes a successful update. The 100% schema coverage helps, but more behavioral context 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?

Schema description coverage is 100%, so the schema already fully documents all 6 parameters. The description doesn't add any parameter-specific information beyond what's in the schema descriptions. The baseline of 3 is appropriate when the schema does all the parameter documentation 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 ('Update a boolean attribute') and the resource ('boolean attribute'), making the purpose immediately understandable. However, it doesn't differentiate this tool from its sibling 'databases_update_*_attribute' tools (like databases_update_string_attribute), which all update attributes of different types.

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 when to choose this over other attribute update tools, when to use it versus creating a new attribute, or any prerequisites beyond what's implied by 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?

No annotations are provided, so the description carries the full burden of behavioral disclosure. It states 'Update a collection' which implies a mutation operation, but it doesn't describe side effects (e.g., whether changes are reversible), permission requirements, rate limits, or what happens to unspecified fields. For a mutation tool with zero annotation coverage, this is a significant gap in 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, straightforward sentence that efficiently states the core action. It's front-loaded with the essential information ('Update a collection'), though it could be more structured by including key details. There's no wasted verbiage, making it appropriately concise for its minimal content.

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

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

Given the complexity of updating a database collection with 6 parameters, no annotations, and no output schema, the description is incomplete. It doesn't address behavioral aspects like mutation effects, error conditions, or return values, leaving significant gaps for the agent to navigate. This is inadequate for a tool with multiple parameters and no structured safety hints.

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 description coverage is 100%, with detailed parameter descriptions in the input schema (e.g., 'Collection name. Max length: 128 chars.'). The tool description adds no additional meaning beyond what the schema provides, such as explaining relationships between parameters or usage examples. With high schema coverage, 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 states the verb ('Update') and resource ('a collection'), but it's vague about what aspects can be updated. It doesn't differentiate from sibling tools like 'databases_update' or 'databases_update_document', which also perform updates on different resources. The purpose is clear at a high level but lacks specificity about scope.

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. With many sibling tools for updating various database components (e.g., 'databases_update_document', 'databases_update_attribute'), the description offers no context on prerequisites, use cases, or exclusions. This leaves the agent to 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?

With no annotations provided, the description carries full burden but offers minimal behavioral insight. It notes that changing the 'default' value won't affect existing documents—a useful constraint—but omits critical details like permission requirements, whether the update is reversible, error conditions, or response format. For a mutation tool, this leaves significant 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 brief and front-loaded with the core purpose. The second sentence adds important behavioral context without redundancy. However, it could be more structured by explicitly listing key parameters or usage scenarios.

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 mutation tool with 6 parameters, no annotations, and no output schema, the description is insufficient. It lacks information on permissions, side effects, error handling, and return values, leaving the agent without critical context for safe and effective 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 100%, so parameters are well-documented in the schema itself. The description adds no additional parameter semantics beyond the schema's details, such as explaining 'new_key' for renaming or interactions between 'required' and 'default'. Baseline 3 is appropriate when 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 clearly states the action ('Update a date time attribute') and specifies the resource being modified. It distinguishes itself from sibling tools like 'databases_create_datetime_attribute' by focusing on updates rather than creation, but doesn't explicitly contrast with other update_attribute tools (e.g., 'databases_update_boolean_attribute').

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., attribute must exist), compare with other update_attribute tools, or indicate when not to use it (e.g., for non-datetime attributes).

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

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

With no annotations provided, the description carries full burden. It mentions the 'patch method' for partial updates, which adds useful behavioral context beyond the schema. However, it lacks critical details like required permissions, whether the operation is idempotent, error conditions, or what happens to unspecified fields (implied as unchanged but not stated). For a mutation tool with zero annotation coverage, this is insufficient.

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 with zero waste, clearly front-loading the core purpose. However, it could be slightly more structured by explicitly separating the 'what' from the 'how' (patch method).

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 mutation tool with 5 parameters, no annotations, and no output schema, the description is incomplete. It lacks information about required permissions, error handling, idempotency, and what the tool returns. The context signals indicate complexity (nested objects, multiple parameters), but the description doesn't adequately address these aspects.

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

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

Schema description coverage is 100%, so the schema already documents all 5 parameters thoroughly. The description adds minimal value by implying that 'data' uses patch semantics (partial updates), but doesn't provide additional syntax or format details beyond what the schema states. 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 action ('Update a document') and specifies the method ('by its unique ID'), which distinguishes it from bulk update tools like 'databases_update_documents'. However, it doesn't explicitly differentiate from 'databases_upsert_document' which might also update documents, making it slightly less specific than 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 minimal guidance, mentioning the 'patch method' for partial updates but not when to use this tool versus alternatives like 'databases_update_documents' (bulk updates) or 'databases_upsert_document' (create-or-update). No explicit when-not-to-use or prerequisite information is included.

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

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

With no annotations provided, the description carries full burden for behavioral disclosure. It only mentions that the endpoint is experimental and may have breaking changes, which is useful context about stability and reliability. However, it doesn't disclose whether this is a read or write operation (though 'update' in the name suggests mutation), what permissions are required, rate limits, or what happens when documents are updated. The warning adds some value but leaves critical behavioral traits unaddressed.

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 that efficiently communicates the experimental warning. There's no wasted space or redundant information. However, it's arguably too concise since it omits the tool's functional purpose entirely, which prevents it from earning a perfect score.

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 this is a mutation tool (implied by 'update' in the name) with 4 parameters, no annotations, and no output schema, the description is incomplete. It lacks information about what the tool does, when to use it, behavioral expectations beyond the experimental warning, and output format. The warning is useful but insufficient for a tool of this complexity.

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

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

Schema description coverage is 100%, so the schema already documents all four parameters thoroughly. The description adds no additional information about parameter meaning, usage, or relationships beyond what's in the schema. According to the rules, when schema coverage is high (>80%), the baseline score is 3 even with no parameter 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 is a warning about the experimental nature of the endpoint but provides no information about what the tool actually does. It doesn't state the verb (update) or resource (documents) that the tool operates on, nor does it distinguish from sibling tools like 'databases_update_document' or 'databases_upsert_documents'. This is essentially missing functional purpose 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 offers no guidance on when to use this tool versus alternatives. It doesn't mention any context, prerequisites, or exclusions for usage. The warning about experimental status might imply caution but doesn't provide actionable usage guidance relative to sibling tools.

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

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

With no annotations provided, the description carries the full burden. It discloses a key behavioral trait: 'Changing the `default` value will not update already existing documents,' which is valuable for understanding mutation effects. However, it lacks other critical details like permissions needed, error conditions, or whether the operation is idempotent.

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 an important behavioral note. There's 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 mutation tool with no annotations and no output schema, the description is minimally adequate. It covers the basic purpose and one behavioral constraint, but lacks details on permissions, error handling, or return values, which are important given the tool's complexity and lack of structured metadata.

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 6 parameters. The description adds no additional parameter semantics beyond what's in the schema, such as explaining interactions between parameters. This 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 ('Update') and resource ('email attribute'), making the purpose understandable. However, it doesn't differentiate from sibling tools like databases_update_string_attribute or databases_update_boolean_attribute, which have identical structures but different attribute types.

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 needing an existing email attribute, nor does it compare with sibling tools for creating or deleting attributes, leaving the agent without usage context.

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

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

The description adds one important behavioral detail: 'Changing the `default` value will not update already existing documents.' Since no annotations are provided, the description carries full burden. However, it doesn't disclose other critical behaviors like whether this is a destructive operation, what permissions are required, error conditions, or what happens to documents with invalid enum values after update.

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 - just two sentences that directly state the purpose and one important behavioral constraint. Every word earns its place with zero waste or redundancy. The critical behavioral detail is front-loaded immediately after the purpose statement.

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

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

For a mutation tool with 7 parameters, no annotations, and no output schema, the description is minimal. It covers the basic purpose and one behavioral constraint but lacks information about side effects, error handling, return values, or prerequisites. Given the complexity of updating database schema attributes, 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?

With 100% schema description coverage, the schema already documents all 7 parameters thoroughly. The description doesn't add any parameter-specific information beyond what's in the schema. The baseline is 3 when schema coverage is high, and the description doesn't compensate with additional parameter context.

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 an enum attribute') and specifies the resource being modified. It distinguishes from sibling tools by focusing specifically on enum attributes rather than other attribute types like boolean, string, etc. However, it doesn't explicitly differentiate from other update_attribute tools beyond the enum specificity.

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

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

The description provides no guidance on when to use this tool versus alternatives. With many sibling tools including various attribute update operations (databases_update_boolean_attribute, databases_update_string_attribute, etc.), there's no indication of when an enum attribute update is appropriate versus other attribute types or general database updates.

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

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

With no annotations provided, the description carries full burden for behavioral disclosure. It mentions one important behavioral constraint (changing default doesn't affect existing documents), but fails to address other critical aspects like permissions needed, whether this is a destructive operation, error handling, or what the tool returns. For a mutation tool with 8 parameters, this is insufficient.

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 communicates the core function and one critical behavioral constraint. It's front-loaded with the main purpose and wastes no words on redundant information.

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

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

For a mutation tool with 8 parameters, no annotations, and no output schema, the description is incomplete. It doesn't explain what happens on success/failure, what permissions are required, or how this tool differs from similar update_attribute tools. The single behavioral note about default values is helpful but insufficient for comprehensive 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?

Schema description coverage is 100%, so the schema already documents all 8 parameters thoroughly. The description adds minimal value beyond the schema by mentioning the behavioral implication of the 'default' parameter, but doesn't provide additional context about parameter interactions or usage patterns.

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 ('Update') and resource ('a float attribute'), making the purpose immediately understandable. It distinguishes this tool from creation tools by focusing on modification rather than creation, though it doesn't explicitly differentiate from other update_attribute siblings beyond the float 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?

The description provides no guidance on when to use this tool versus alternatives like other attribute update tools or general database update operations. There's no mention of prerequisites, error conditions, or typical use cases beyond the basic function.

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

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

With no annotations provided, the description carries the full burden of behavioral disclosure. It mentions that changing the 'default' value won't update existing documents, which is useful context, but fails to cover critical aspects like whether this is a destructive mutation, permission requirements, error handling, or response format. This leaves significant gaps for a tool that modifies database attributes.

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 action and a key behavioral note. It's front-loaded with the main purpose and avoids any unnecessary wording, making it highly concise 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 complexity of updating a database attribute with 8 parameters, no annotations, and no output schema, the description is insufficient. It lacks details on behavioral traits, error conditions, and what the tool returns, making it incomplete for safe and effective use by an AI 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?

The schema description coverage is 100%, meaning all parameters are documented in the input schema. The description adds minimal value by hinting at the 'default' parameter's behavior, but doesn't provide additional semantics beyond what the schema already explains, such as clarifying relationships between parameters like 'required' and 'default'.

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

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

The description clearly states the verb ('Update') and resource ('integer attribute'), making the purpose understandable. However, it doesn't explicitly differentiate this from sibling tools like 'databases_update_float_attribute' or 'databases_update_string_attribute' beyond the 'integer' in the name, which is why it doesn't reach a 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, such as needing an existing integer attribute, or compare it to other update_attribute tools, leaving the agent to infer usage from the 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?

With no annotations provided, the description carries the full burden of behavioral disclosure. It mentions one behavioral trait—that changing the 'default' value won't update existing documents—which is useful. However, it lacks other critical details: whether this is a mutation (implied by 'Update'), permission requirements, error conditions, or what the response looks like. This partial disclosure is insufficient for a mutation 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 a single, efficient sentence that gets straight to the point without unnecessary words. It's appropriately sized for its purpose, though it could be slightly more informative without sacrificing 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 mutation tool with 6 parameters, no annotations, and no output schema, the description is incomplete. It lacks details on behavioral traits (e.g., side effects, permissions), usage context, and output expectations. The single behavioral note about 'default' is helpful but insufficient to compensate for the overall gaps.

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

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

Schema description coverage is 100%, so the schema already documents all parameters thoroughly. The description adds minimal value by clarifying the 'default' parameter's effect on existing documents, but doesn't provide additional meaning for other parameters beyond what the schema states. This 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 ('Update') and resource ('ip attribute'), making the purpose understandable. However, it doesn't distinguish this tool from sibling tools like 'databases_update_boolean_attribute' or 'databases_update_string_attribute' beyond the 'ip' qualifier in the name, which is why it doesn't reach 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., needing an existing IP attribute), compare it to other update_attribute tools, or specify when it's appropriate versus creating a new attribute. This leaves the agent with minimal context 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?

With no annotations provided, the description carries the full burden of behavioral disclosure. It states 'Update' which implies a mutation, but fails to describe critical behaviors: whether this requires specific permissions, if changes are reversible, what happens to existing data when updating attributes, or any rate limits/errors. The link adds some context but doesn't compensate for the lack of explicit behavioral details in the description.

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—just one sentence plus a link. It's front-loaded with the core action ('Update relationship attribute') and avoids unnecessary elaboration. However, the brevity comes at the cost of completeness, as it lacks essential details. Still, within its limited scope, it's structured efficiently without wasted 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?

Given the complexity of updating database relationship attributes (a mutation operation with 5 parameters), no annotations, and no output schema, the description is incomplete. It doesn't cover behavioral aspects, usage context, or output expectations. The external documentation link provides some compensation but doesn't make the description itself complete for agent use. A mutation tool with this complexity needs more explicit guidance in 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 100%, so the schema already documents all 5 parameters thoroughly. The description adds no parameter-specific information beyond what's in the schema (e.g., it doesn't explain what 'on_delete' constraints are or how 'new_key' interacts with existing data). With high schema coverage, the baseline score of 3 is appropriate as the description doesn't 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 'Update relationship attribute' is essentially a tautology that restates the tool name with minimal elaboration. While it identifies the verb ('Update') and resource ('relationship attribute'), it lacks specificity about what aspects are updated (e.g., key, constraints) and doesn't differentiate from sibling tools like databases_update_boolean_attribute or databases_update_string_attribute. The link to documentation is helpful but external, not part of the description itself.

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 explicit guidance is provided on when to use this tool versus alternatives. The description doesn't mention prerequisites (e.g., existing relationship attributes), exclusions, or comparisons to sibling tools like databases_create_relationship_attribute or databases_delete_attribute. The link to external docs might imply context, but within the description text itself, there's no usage direction.

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

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

With no annotations provided, the description carries the full burden of behavioral disclosure. It adds one important behavioral detail about the 'default' parameter not updating existing documents, which is valuable context beyond the schema. However, it doesn't disclose other critical behaviors like whether this is a destructive operation, what permissions are required, error conditions, or what the response looks like.

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 just two sentences, both of which earn their place. The first sentence states the core purpose, and the second provides crucial behavioral context about the 'default' parameter. There's zero wasted text or 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 mutation tool with 7 parameters and no annotations or output schema, the description is minimal but covers the essential action. The behavioral detail about the 'default' parameter adds some value, but significant gaps remain regarding permissions, error handling, and response format. It's adequate for the simplest use case but incomplete for robust 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?

Schema description coverage is 100%, so the schema already documents all 7 parameters thoroughly. The description adds one semantic clarification about the 'default' parameter's effect on existing documents, which provides useful context beyond the schema's technical description. This justifies a baseline score of 3, as the schema does most of the work with the description adding marginal value.

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

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

The description clearly states the action ('Update a string attribute') and resource ('string attribute'), making the purpose immediately understandable. However, it doesn't differentiate this tool from sibling tools like databases_update_boolean_attribute or databases_update_email_attribute, which have identical structures but for different attribute types.

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. With many sibling tools for updating different attribute types (boolean, datetime, email, etc.), there's no indication that this is specifically for string attributes versus other types, nor any mention of prerequisites or when this tool would be appropriate versus creating a new attribute.

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

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

With no annotations provided, the description carries the full burden of behavioral disclosure. It mentions a key behavioral trait—that changing the 'default' value won't update existing documents—which adds value. However, it fails to cover other critical aspects like whether this is a mutation (implied by 'Update'), potential side effects, error conditions, or required permissions, leaving significant 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 a single, efficient sentence that conveys essential information without unnecessary words. It is front-loaded with the core action and resource, 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?

Given the complexity of updating a database attribute (a mutation operation) with no annotations and no output schema, the description is insufficient. It lacks details on return values, error handling, authentication needs, or broader context like how this fits into database management workflows, making it incomplete for effective tool 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 input schema has 100% description coverage, so the schema already documents all parameters thoroughly. The description adds minimal value by hinting at the 'default' parameter's behavior, but it doesn't provide additional semantic context beyond what the schema offers, aligning with the baseline score of 3 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 ('Update') and resource ('an url attribute'), making the purpose understandable. However, it doesn't explicitly differentiate this from sibling tools like 'databases_update_string_attribute' or 'databases_update_email_attribute' beyond the 'url' in the tool name, which is why it doesn't reach a score of 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, such as other attribute update tools or related operations like 'databases_update_document'. It lacks context about prerequisites, dependencies, or typical scenarios for updating a URL attribute.

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

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

With no annotations provided, the description carries the full burden of behavioral disclosure. The warning about experimental status and potential breaking changes is valuable risk information, but it doesn't describe what the tool actually does behaviorally - whether it creates or updates documents, what happens on conflicts, what permissions are required, or what the response looks like. The description provides only partial 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 appropriately concise - a single sentence warning about experimental status. While it's severely lacking in functional information, what's present is efficiently stated without redundancy. The warning is front-loaded and earns its place by providing important risk information that wouldn't be captured elsewhere.

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 mutation tool with 5 parameters, no annotations, and no output schema, the description is incomplete. While it provides important experimental status warnings, it completely omits the core functionality explanation, behavioral expectations, and usage context. The agent would need to infer the tool's purpose from the name alone, which is insufficient for a tool with this complexity.

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

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

Schema description coverage is 100%, so the schema already documents all 5 parameters thoroughly. The description adds no parameter information beyond what's in the schema. According to scoring rules, when schema coverage is high (>80%), the baseline is 3 even with no parameter information 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 contains no statement of what the tool does - it only provides a warning about the experimental nature of the endpoint. The name 'databases_upsert_document' suggests it creates or updates a document, but the description provides zero functional information about the tool's purpose, making it tautological at best (restating the name) and misleading at worst by omitting the core functionality.

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. With sibling tools like 'databases_create_document', 'databases_update_document', and 'databases_upsert_documents', there's no indication of when this single-document upsert is appropriate versus those other operations. The warning about experimental status doesn't constitute usage 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?

The description provides a warning about the experimental nature of the endpoint, which is useful behavioral context not captured in annotations (none provided). However, it fails to describe what 'upsert' means operationally (insert or update based on existence), whether this is a batch operation, what happens on conflicts, or any authentication/rate limit considerations. For a mutation tool with no annotations, this is insufficient.

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?

While concise, the description is under-specified rather than efficiently structured. It wastes its single sentence on a warning without providing any functional information. A well-structured description would front-load the purpose before adding caveats.

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 description is completely inadequate for a tool with 3 parameters, no annotations, and no output schema. It doesn't explain what the tool does, when to use it, what 'upsert' means, or what the operation returns. For a database mutation tool, this leaves critical gaps in 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?

Schema description coverage is 100%, so all parameters are documented in the schema. The description adds no additional parameter information beyond what's already in the structured fields. The baseline score of 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 provides no information about what the tool actually does. It only contains a warning about the feature being experimental, without stating the verb (upsert) or resource (documents in a database collection). This is a tautology that restates the name/title without explaining functionality.

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. The description doesn't mention sibling tools like databases_create_document, databases_update_document, or databases_upsert_document, nor does it explain when upserting multiple documents is appropriate versus single-document operations.

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