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

The description adds valuable context beyond annotations: it specifies that no credentials are required, which isn't covered by readOnlyHint or idempotentHint. Annotations already indicate it's safe (read-only, idempotent), so the bar is lower, but the credential-free aspect is a useful behavioral trait that enhances transparency.

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

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

The description is a single, efficient sentence that front-loads the key information: it states what the tool does and a critical constraint (no credentials needed). Every word earns its place, with no redundancy or 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 simplicity (0 parameters, no output schema) and rich annotations (readOnlyHint, idempotentHint), the description is nearly complete. It covers purpose, usage, and a key behavioral trait. A minor gap is the lack of detail on what 'server status' includes, but with annotations ensuring safety, this is acceptable.

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

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

With 0 parameters and 100% schema description coverage, the baseline is 4. The description reinforces this by stating 'without requiring any credentials,' which aligns with the empty input schema, adding clarity that no inputs are needed for this operation.

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 explicitly states the verb ('Returns') and resource ('server status'), making the purpose clear. It also distinguishes itself from siblings by specifying it doesn't require credentials, which is unique among the listed tools that mostly involve data manipulation or retrieval requiring authentication.

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

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

The description provides explicit guidance on when to use this tool: for checking server status without credentials. It implies an alternative scenario where other tools might require credentials, helping differentiate it from siblings that likely need authentication for operations like create, delete, or search.

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 tool adds records to lists, implying a mutation operation, but doesn't describe permissions required, whether the operation is idempotent, error handling, or what happens if the record is already in the list. This leaves significant gaps 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, efficient sentence that front-loads the core purpose ('Add a company or person to a CRM list') and includes helpful examples ('sales pipeline, lead list, etc.') without unnecessary details. Every word earns its place, making it easy to scan and understand 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 this is a mutation tool with no annotations and no output schema, the description is incomplete. It lacks behavioral details like side effects, error conditions, or return values, and doesn't provide usage context relative to siblings. While concise, it fails to address key aspects needed for safe and effective tool invocation in a complex CRM environment.

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

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

Schema description coverage is 100%, so the schema fully documents all 4 parameters (listId, recordId, objectType, initialValues) with descriptions and an enum for objectType. The description adds no parameter-specific information beyond what's in the schema, such as format examples or constraints, so it meets the baseline for high schema coverage without compensating 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 ('Add') and resource ('a company or person to a CRM list'), with examples like 'sales pipeline, lead list' providing context. It distinguishes from siblings like 'remove-record-from-list' by specifying addition, but doesn't explicitly differentiate from 'update-list-entry' or 'create-record' beyond the 'add to list' focus.

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 on when to use this tool versus alternatives is provided. The description implies usage for adding records to lists, but doesn't mention prerequisites, when to choose this over 'create-record' (which might create a new record vs. adding an existing one), or when to use 'update-list-entry' instead. It lacks context on appropriate scenarios 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 but provides minimal behavioral information. It mentions 'advanced multiple conditions' and 'complex sales pipeline queries' which gives some context about complexity, but doesn't disclose important traits like whether this is a read-only operation, potential performance implications, pagination behavior (though schema hints at it), error conditions, or authentication requirements. For a tool with complex nested parameters and no annotations, this is inadequate.

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 communicates the core purpose upfront. It uses parenthetical clarification effectively. However, it could be slightly more structured by separating the 'what' from the 'when' or providing a brief example of what 'advanced' means.

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

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

For a tool with complex nested parameters (4 parameters with deep nesting), no annotations, and no output schema, the description is insufficient. It doesn't explain the return format, error handling, performance characteristics, or provide examples of the 'advanced' filtering. The agent would struggle to use this effectively without trial and error despite the good schema documentation.

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

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

Schema description coverage is 100%, so the schema already documents all parameters thoroughly. The description adds minimal value beyond the schema - it mentions 'advanced multiple conditions' which aligns with the complex 'filters' parameter structure, but doesn't provide additional context about parameter relationships, usage examples, or semantic meaning 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 ('filter entries') and resource ('in a CRM list'), and specifies the capability ('with advanced multiple conditions'). It distinguishes from simpler filtering tools like 'filter-list-entries' by emphasizing 'advanced' and 'complex sales pipeline queries'. However, it doesn't explicitly name the sibling 'filter-list-entries' for direct comparison.

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 ('complex sales pipeline queries') suggesting this tool is for more sophisticated filtering needs. However, it doesn't explicitly state when to use this versus simpler alternatives like 'filter-list-entries' or 'search' tools, nor does it mention prerequisites or exclusions. The guidance is present but not explicit.

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

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

Annotations already declare readOnlyHint=true and idempotentHint=true, so the agent knows this is a safe, repeatable read operation. The description adds some context about 'complex filtering across all resource types', which helps understand scope, but doesn't provide additional behavioral details like rate limits, authentication requirements, or performance characteristics. No contradiction with annotations exists.

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

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

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

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

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

Given the tool's complexity (7 parameters, nested objects) and lack of output schema, the description provides minimal but adequate context. With annotations covering safety/idempotency and schema covering parameters, the description's main gap is distinguishing from sibling tools. For a search tool without output schema, more guidance on result format would be helpful but isn't critical.

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

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

With 100% schema description coverage, the input schema thoroughly documents all 7 parameters including examples and constraints. The description adds no parameter-specific information beyond what's already in the schema. The baseline score of 3 reflects adequate parameter documentation coming entirely from the schema rather than the description.

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

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

The description clearly states the tool performs 'advanced search with complex filtering across all resource types', which specifies the verb (search), scope (advanced/complex), and resource coverage (all resource types). However, it doesn't explicitly differentiate from sibling tools like 'search', 'search-records', or 'batch-search', which reduces the score from 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. With multiple search-related sibling tools (search, search-records, batch-search, search-by-content, etc.), the agent receives no indication of when this 'advanced search' is preferable or what distinguishes it from simpler search tools.

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

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

Annotations indicate readOnlyHint=false and destructiveHint=true, which the description doesn't contradict. The description mentions 'delete' as an operation type, aligning with the destructive hint. However, it adds minimal behavioral context beyond annotations—no information about rate limits, authentication needs, error handling, or what 'bulk' entails (e.g., atomicity, batch size limits). With annotations covering safety, the description adds some value but lacks depth.

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

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

The description is a single, efficient sentence that lists the operation types. It's front-loaded with the core purpose. However, it could be more structured by separating operation types or adding brief context, but it avoids unnecessary verbosity.

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

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

Given the tool's complexity (7 parameters, destructive operations, no output schema), the description is inadequate. It doesn't explain return values, error handling, or how batch results are formatted. With annotations providing basic safety info but no output schema, the description should offer more context to help the agent understand behavioral outcomes.

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. The description adds no specific parameter semantics beyond implying operations like create/update/delete/get/search. It doesn't explain relationships between parameters (e.g., how 'operations' interacts with 'operation_type') or clarify legacy formats. Baseline 3 is appropriate as the schema handles most 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 states the tool performs bulk operations and lists the operation types (create, update, delete, get, search), which gives a general purpose. However, it's vague about what resources are operated on and doesn't distinguish this from sibling tools like batch-search, create-record, or update-record. The description lacks specificity about the scope or target of these operations.

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

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

The description provides no guidance on when to use this tool versus alternatives. With many sibling tools for individual operations (create-record, update-record, delete-record, search, etc.), there's no indication of when batch processing is preferred over single operations, what prerequisites exist, or any limitations. The agent must infer usage from the tool name alone.

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

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

Annotations already declare readOnlyHint=true and idempotentHint=true, so the agent knows this is a safe, repeatable read operation. The description adds the 'parallel' execution context, which is useful behavioral information beyond annotations, but doesn't cover rate limits, performance characteristics, or error handling for failed queries.

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 ('Perform batch search operations') and adds key context ('with multiple queries in parallel'). There's zero wasted verbiage 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 search tool with good annotations (read-only, idempotent) and full schema coverage, the description is minimally adequate. However, without an output schema, it doesn't explain what results look like (e.g., array of result sets, error handling for partial failures), leaving gaps in understanding the tool's behavior.

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

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

Schema description coverage is 100%, with all parameters well-documented in the schema itself. The description doesn't add any meaningful parameter semantics beyond what's already in the schema (e.g., it doesn't explain query format, result structure, or how parallel execution affects parameter interpretation). 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 ('Perform batch search operations') and resource ('multiple queries'), specifying parallel execution. It distinguishes from simple 'search' tools by emphasizing batch processing, though it doesn't explicitly differentiate from all sibling search tools like 'advanced-search' or 'search-by-content'.

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 'search', 'advanced-search', or other sibling search tools. It mentions parallel execution but doesn't specify scenarios where batch processing is preferred over individual searches or what trade-offs exist.

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

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

Annotations indicate this is a non-destructive write operation (readOnlyHint: false, destructiveHint: false), which the description aligns with by using 'Create'. The description adds minimal behavioral context beyond annotations—it specifies the record types but doesn't cover error conditions, permissions, or what happens on success (e.g., whether a note ID is returned). With annotations covering safety, a baseline 3 is appropriate for the limited added value.

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

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

The description is a single, efficient sentence with zero wasted words. It front-loads the core purpose ('Create a note') and immediately specifies scope, 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 moderate complexity (4 required parameters, no output schema), the description is minimally adequate. It covers the 'what' but lacks context on usage, errors, or output. With annotations providing safety info and schema covering parameters, the description is incomplete but not critically so for basic 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%, with all parameters clearly documented in the schema. The description adds no parameter-specific information beyond implying 'record type' relates to 'resource_type', but doesn't explain the enum values or parameter interactions. This meets the baseline 3 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 a note') and specifies the target resources ('for any record type (companies, people, deals)'), providing a specific verb+resource combination. However, it doesn't distinguish this tool from potential sibling note-creation tools (though none are listed), and the parenthetical list omits some resource_types from the enum (e.g., 'lists', 'tasks'), creating minor inconsistency.

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 valid record IDs), exclusions, or comparisons to sibling tools like 'create-record' or 'list-notes'. The agent must infer usage solely 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?

Annotations already indicate this is a non-destructive write operation (readOnlyHint: false, destructiveHint: false). The description adds minimal behavioral context beyond this - it doesn't mention authentication requirements, rate limits, or what happens on creation failure. However, it doesn't contradict the annotations either.

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 purpose efficiently. There's no wasted language or unnecessary elaboration, making it easy to parse while still being 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?

For a creation tool with no output schema and multiple sibling alternatives, the description is insufficient. It doesn't explain what 'supported types' means, what the creation response looks like, or how this differs from other creation tools in the server. The annotations cover basic safety but the description lacks crucial operational 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?

With 100% schema description coverage, the input schema already documents all three parameters thoroughly. The description adds no additional parameter semantics beyond what's in the schema - it doesn't explain the relationship between 'resource_type' and 'record_data' or provide examples of valid record structures.

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 ('create') and resource ('new record of any supported type'), making the purpose immediately understandable. However, it doesn't explicitly differentiate from sibling tools like 'create-note' or 'add-record-to-list', which would require more specific scope definition.

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

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

The description provides no guidance on when to use this tool versus alternatives. With sibling tools like 'create-note', 'add-record-to-list', and 'update-record' available, there's no indication of when this general creation tool is preferred over more specific ones or what prerequisites might be needed.

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

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

Annotations already declare destructiveHint=true and readOnlyHint=false, so the agent knows this is a destructive write operation. The description adds minimal context beyond this—it doesn't specify whether deletions are permanent, reversible, have confirmation steps, or affect related data. With annotations covering the safety profile, this meets baseline expectations but doesn't provide rich behavioral details.

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

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

The description is a single, efficient sentence with zero wasted words. It's front-loaded with the core action and resource, making it easy to parse quickly. Every word earns its place without 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 destructive tool with no output schema, the description is minimally adequate but lacks depth. Annotations cover safety (destructive), and schema covers parameters fully, but the description doesn't address critical context like what 'delete' entails (permanent? soft delete?), error handling, or return values. It meets basic requirements but leaves gaps for informed usage.

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

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

Schema description coverage is 100%, with both parameters clearly documented in the schema (record_id and resource_type with enum values). The description adds no additional parameter semantics beyond what the schema provides, such as explaining the relationship between record_id and resource_type or providing examples. 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 ('Delete') and resource ('record of any supported type'), providing a specific verb+resource combination. However, it doesn't explicitly differentiate from sibling tools like 'remove-record-from-list' or 'batch-operations' that might also involve deletion operations, preventing 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 like 'remove-record-from-list' (which removes from lists but doesn't delete) or 'batch-operations' (which might handle bulk deletions). It lacks context about prerequisites, permissions needed, or when deletion is appropriate versus other operations.

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

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

Annotations already declare readOnlyHint=true and idempotentHint=true, so the agent knows this is a safe, repeatable read operation. The description adds the scope of 'any resource type' and implies a cataloging function, which provides useful context beyond annotations. However, it doesn't describe behavioral details like response format, pagination, or error conditions that would be helpful for a discovery 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 immediately conveys the core function. Every word earns its place with no redundancy or fluff. It's appropriately sized for a simple discovery tool and front-loads the essential information without unnecessary elaboration.

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

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

For a read-only, idempotent discovery tool with good annotations and full schema coverage, the description is minimally adequate. However, without an output schema, the description doesn't explain what the discovery results look like (e.g., attribute names, types, metadata). Given the tool's purpose of revealing available attributes, more information about the return format would be beneficial for contextual completeness.

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

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

Schema description coverage is 100%, so the schema fully documents both parameters. The description mentions 'resource type' which aligns with the schema's enum, but adds no additional semantic context about parameter usage, relationships, or constraints beyond what's already in the structured schema. With complete 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 tool's purpose as discovering available attributes for resource types, using specific verbs ('discover') and resources ('attributes', 'resource type'). It distinguishes from siblings like 'get-attributes' by emphasizing discovery of what's available rather than retrieving specific attribute data. However, it doesn't explicitly contrast with 'get-attributes' in the description text 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?

The description provides no guidance on when to use this tool versus alternatives. It doesn't mention sibling tools like 'get-attributes' or explain scenarios where discovering available attributes is preferable to directly retrieving attribute data. There's no context about prerequisites, timing, or exclusions for usage.

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

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

Annotations already indicate read-only and idempotent behavior, so the description does not need to repeat these. It adds context by specifying that it retrieves 'full record payload', which clarifies the scope of data returned beyond what annotations provide. However, it lacks details on error handling, response format, or any limitations like rate limits.

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 ('Retrieve the full record payload') and includes essential context ('for a search result ID'). There is no wasted verbiage, 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 tool's simplicity (1 parameter, 100% schema coverage, read-only/idempotent annotations) and lack of output schema, the description is adequate but minimal. It covers the basic purpose and input context but does not address output details, error cases, or integration with sibling tools, leaving some gaps in completeness.

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

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

Schema description coverage is 100%, with the parameter 'id' fully documented in the schema as 'Identifier emitted by the search tool (<resource>:<id>)'. The description adds minimal value by restating 'search result ID' but does not provide additional semantics beyond what the schema already covers.

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 ('Retrieve'), the target ('full record payload'), and the required input ('for a search result ID'). It distinguishes itself from siblings like 'search' or 'get-record-details' by focusing on fetching complete data for a pre-identified search result.

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

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

The description implies usage by referencing 'search result ID' from the 'search tool', suggesting it should be used after search operations. However, it does not explicitly state when to use this versus alternatives like 'get-record-details' or 'get-detailed-info', nor does it provide exclusions or prerequisites beyond the ID requirement.

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 tool filters entries but doesn't mention whether this is a read-only operation, if it affects data, what permissions are required, or how results are returned (e.g., pagination details beyond schema). The description is minimal and lacks crucial behavioral context for a filtering 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 directly states the tool's purpose with a relevant example. It's front-loaded with the core functionality and wastes no words. This is appropriately concise for a straightforward filtering 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?

For a filtering tool with 6 parameters, no annotations, and no output schema, the description is insufficient. It doesn't explain the tool's behavior, return format, error conditions, or how it differs from similar tools like 'advanced-filter-list-entries'. The agent lacks context to use this tool effectively beyond basic parameter filling.

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 parameter-specific information beyond implying filtering by attribute. It doesn't explain parameter interactions, value types, or provide examples beyond the generic 'e.g., stage, status'. With high 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 ('filter entries') and resource ('in a CRM list'), with a specific attribute example ('e.g., stage, status'). It distinguishes from siblings like 'get-list-entries' (no filtering) and 'advanced-filter-list-entries' (more complex filtering), but doesn't explicitly name alternatives. This is clear but lacks explicit sibling differentiation.

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

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

The description provides no guidance on when to use this tool versus alternatives like 'advanced-filter-list-entries' or 'search'. It mentions filtering by a specific attribute but doesn't specify prerequisites, limitations, or when other tools might be more appropriate. This leaves the agent with minimal 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?

No annotations are provided, so the description carries the full burden of behavioral disclosure. While it states the tool filters entries, it doesn't describe whether this is a read-only operation, what permissions are required, how results are returned (e.g., pagination behavior beyond schema hints), or potential side effects. The description adds minimal behavioral context beyond the basic function.

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 is front-loaded with the core purpose and includes helpful examples in parentheses. There is no wasted language, and every part of the sentence contributes to understanding the tool's function.

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

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

Given the tool's complexity (7 parameters, filtering logic) and lack of annotations or output schema, the description is minimally adequate. It covers the basic purpose but lacks details on behavioral traits, usage context, and output format. For a filtering tool with no structured output information, more guidance on result handling 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 all 7 parameters thoroughly. The description adds minimal value beyond the schema—it mentions filtering 'based on parent record properties' and gives examples ('companies by industry, people by role'), but doesn't provide additional syntax, format details, or constraints not already in the schema descriptions. 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 tool's purpose: 'Filter CRM list entries based on parent record properties' with specific examples like 'find companies by industry, people by role'. It uses a specific verb ('filter') and resource ('CRM list entries'), but doesn't explicitly distinguish it from sibling tools like 'filter-list-entries' or 'filter-list-entries-by-parent-id'.

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 examples ('find companies by industry, people by role') which imply context, but doesn't specify when to choose this over similar tools like 'filter-list-entries' or 'filter-list-entries-by-parent-id', nor does it mention any 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 full burden. It mentions filtering behavior but doesn't disclose pagination details (implied by parameters), rate limits, authentication requirements, error conditions, or what happens with invalid IDs. The description adds minimal behavioral context beyond the basic 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 that front-loads the core purpose and includes helpful examples. Every word earns its place with zero 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 read-only filtering tool with 4 parameters (2 required), 100% schema coverage, and no output schema, the description is adequate but incomplete. It explains the what but lacks behavioral details (pagination behavior, error handling) that would help an agent use it correctly, especially given no annotations.

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

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

Schema description coverage is 100%, so parameters are fully documented in the schema. The description adds marginal value by clarifying that 'recordId' refers to a 'parent record' and providing examples ('company or person'), but doesn't explain parameter interactions or constraints beyond what the schema provides.

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

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

The description clearly states the specific action ('Filter CRM list entries') and resource ('by parent record ID'), with explicit examples ('find all lists containing a specific company or person'). It distinguishes from siblings like 'filter-list-entries' (general filtering) and 'get-record-list-memberships' (different perspective).

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 ('find all lists containing a specific company or person') but doesn't explicitly state when to use this tool versus alternatives like 'get-record-list-memberships' or 'filter-list-entries'. No exclusions or prerequisites are mentioned.

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

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

Annotations already declare readOnlyHint=true and idempotentHint=true, so the agent knows this is a safe, repeatable read operation. The description adds value by specifying the scope ('for any resource type') but doesn't disclose additional behavioral traits like rate limits, authentication needs, or what happens with invalid resource types. No contradiction with annotations.

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

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

Single sentence, zero waste. It efficiently conveys the tool's purpose and scope without unnecessary words, making it easy for an AI 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 annotations cover safety (read-only, idempotent) and schema fully describes parameters, the description is minimally adequate. However, with no output schema and multiple sibling tools, it lacks context on return format, error handling, or differentiation from similar tools like 'discover-attributes', 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 fully documents all 4 parameters. The description mentions 'resource type' and implies attribute retrieval but doesn't add meaning beyond what the schema provides (e.g., explaining relationships between parameters or usage examples). Baseline 3 is appropriate given 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 verb 'Get' and the resource 'attributes', specifying it works for multiple resource types (companies, people, lists, records, tasks, deals, notes). It distinguishes from some siblings like 'get-record-details' or 'get-list-details' by focusing on attributes rather than general details, but doesn't explicitly differentiate from 'discover-attributes' which might be a similar tool.

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

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

No guidance on when to use this tool versus alternatives. The description doesn't mention when to choose this over 'get-record-details', 'get-list-details', or 'discover-attributes', nor does it provide context about prerequisites or appropriate scenarios for attribute retrieval.

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

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

Annotations already declare readOnlyHint=true and idempotentHint=true, indicating safe, repeatable read operations. The description adds no behavioral context beyond this, such as rate limits, authentication needs, or data format specifics. It doesn't contradict annotations, but offers minimal additional value.

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

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

The description is a single, efficient sentence that directly states the tool's purpose without unnecessary words. It's appropriately front-loaded, though it could be slightly more structured to highlight key distinctions.

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 annotations cover safety and idempotency, and the schema fully documents parameters, the description is minimally adequate. However, without an output schema, it doesn't explain return values or error handling, leaving gaps in completeness for a tool that fetches detailed data.

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%, fully documenting both parameters (record_id and resource_type with enum values). The description mentions 'specific types of detailed information' but doesn't add meaning beyond the schema's enum list or clarify how parameters interact, so it meets the baseline.

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

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

The description clearly states the verb 'Get' and specifies the types of detailed information (contact, business, social), making the purpose understandable. However, it doesn't explicitly distinguish this tool from similar siblings like 'get-record-details' or 'fetch', which limits its 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 no guidance on when to use this tool versus alternatives. With many sibling tools like 'get-record-details' and 'fetch' that might overlap in functionality, the absence of explicit usage context or exclusions leaves the agent without clear 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?

No annotations are provided, so the description carries full burden. It states this is a read operation ('Get'), but doesn't disclose behavioral traits like authentication requirements, rate limits, error conditions, or what happens if the list ID is invalid. For a tool with no annotation coverage, this leaves significant gaps in understanding how it 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, efficient sentence that front-loads the core purpose. It avoids unnecessary words and directly states what the tool does. The parenthetical examples add useful context without verbosity.

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

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

Given the tool has one parameter with full schema coverage but no annotations or output schema, the description is minimally adequate. It clarifies the tool's focus on list details (not entries or records), but doesn't address behavioral aspects or output format. For a read-only tool with simple inputs, this is acceptable but leaves room for improvement.

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

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

Schema description coverage is 100%, with the single parameter 'listId' fully documented in the schema. The description adds no additional parameter semantics beyond implying the tool fetches details for a list, which is already clear from the schema. This meets the baseline of 3 when schema coverage is high.

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 resource 'details for a specific CRM list', with examples of what details might include (pipeline stages, field configuration). It distinguishes from siblings like 'get-lists' (which lists multiple lists) and 'get-record-details' (which focuses on records rather than lists). However, it doesn't explicitly differentiate from 'get-detailed-info' which might overlap in 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 no guidance on when to use this tool versus alternatives. It doesn't mention prerequisites (e.g., needing a valid list ID), exclusions, or compare to similar tools like 'get-detailed-info' or 'get-list-entries'. The agent must infer usage from the name and 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 but only states what the tool does without disclosing behavioral traits such as pagination behavior (implied by offset/limit but not explained), rate limits, authentication needs, or error handling. It mentions 'companies, people, etc.' but doesn't clarify if this is exhaustive or example-based.

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 with zero waste. It uses parentheses to add clarifying examples without bloating the text.

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

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

For a read operation with 3 parameters and 100% schema coverage but no annotations or output schema, the description is minimally adequate. It covers the basic purpose but lacks details on return values, error cases, or behavioral context that would help an agent use it 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?

Schema description coverage is 100%, so the schema fully documents parameters (listId, limit, offset). The description adds no additional parameter semantics beyond what's in the schema, such as format details for listId or constraints on limit/offset values.

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 resource 'entries for a specific CRM list', with examples like 'companies, people, etc. in sales pipelines' that clarify the type of data. It distinguishes from general search tools but doesn't explicitly differentiate from sibling tools like 'filter-list-entries' or 'advanced-filter-list-entries'.

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

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

No guidance on when to use this tool versus alternatives like 'filter-list-entries', 'advanced-filter-list-entries', or 'search' tools is provided. The description implies usage for retrieving list entries but lacks 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?

No annotations are provided, so the description carries full burden. It mentions 'Get all CRM lists' but doesn't disclose behavioral traits like whether this is a read-only operation, if it requires authentication, rate limits, pagination, or what the return format might be. For a 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, efficient sentence that front-loads the core action ('Get all CRM lists') and includes helpful examples without unnecessary elaboration. Every word earns its place, making it appropriately sized and well-structured.

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

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

Given the tool's low complexity (0 parameters, no output schema), the description is adequate but incomplete. It specifies what is retrieved but lacks details on behavioral aspects like safety, performance, or output format. With no annotations and no output schema, the description should do more to compensate, but it meets minimum viability for a simple retrieval tool.

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

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

The tool has 0 parameters with 100% schema description coverage, so the schema already fully documents the lack of inputs. The description adds value by specifying 'all CRM lists from Attio' and providing examples, which clarifies the resource scope beyond what the empty schema indicates. Baseline for 0 parameters is 4, and the description compensates appropriately.

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 resource 'all CRM lists from Attio', with examples like 'sales pipelines, lead stages, customer segments' that help clarify scope. However, it doesn't explicitly differentiate from sibling tools like 'get-list-details' or 'get-list-entries', which might retrieve specific list information rather than all lists.

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 'get-list-details' or 'filter-list-entries'. It lacks context on prerequisites, exclusions, or comparisons with sibling tools, leaving the agent to infer usage based on 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?

Annotations provide readOnlyHint=true and idempotentHint=true, indicating a safe, repeatable read operation. The description adds value by specifying 'detailed information for any record type', which hints at broader scope beyond basic retrieval, but doesn't disclose rate limits, authentication needs, or error behaviors. No contradiction with annotations exists.

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

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

The description is a single, efficient sentence with zero wasted words. It's front-loaded with the core purpose, making it easy to parse quickly. No unnecessary elaboration or redundancy is present.

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 annotations cover safety and idempotency, and schema covers parameters fully, the description is minimally adequate. However, with no output schema and siblings offering similar functions, it lacks details on return format, error handling, or differentiation, leaving gaps in context for a retrieval tool.

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

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

Schema description coverage is 100%, so parameters are well-documented in the schema. The description adds no additional meaning about parameters beyond implying 'any record type' aligns with the resource_type enum. Baseline 3 is appropriate as the schema carries the burden, but 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 'Get detailed information for any record type' clearly states the verb ('Get') and resource ('detailed information for any record type'), but it's vague about what 'detailed information' entails and doesn't distinguish it from siblings like 'get-detailed-info' or 'get-list-details'. It provides a basic purpose but lacks 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 offers no guidance on when to use this tool versus alternatives. With siblings like 'get-detailed-info', 'search-records', and 'fetch' that might overlap in functionality, there's no indication of context, prerequisites, or exclusions. It leaves the agent to guess based on 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 the full burden of behavioral disclosure. It states the tool 'finds' lists, implying a read-only operation, but does not disclose other traits such as rate limits, authentication needs, pagination behavior, or what happens if the record doesn't exist. This is a significant gap 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 that front-loads the core purpose ('Find all CRM lists that a specific record belongs to') with no wasted words. Every part of the sentence earns its place by specifying the action, scope, and target.

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 adequate for a read operation but incomplete. It covers the basic purpose and parameters (via schema), but lacks details on behavioral traits (e.g., error handling, performance) and output format, which are important for a tool with 4 parameters and no structured output documentation.

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

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

Schema description coverage is 100%, so the schema already documents all parameters thoroughly. The description does not add meaning beyond the schema (e.g., it doesn't explain how 'objectType' and 'recordId' interact or what 'includeEntryValues' entails in practice). Baseline 3 is appropriate when the schema does the heavy lifting.

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

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

The description clearly states the tool's purpose with a specific verb ('Find') and resource ('all CRM lists that a specific record belongs to'), and it distinguishes from siblings like 'get-list-details' (which lists list properties) or 'get-list-entries' (which lists entries within a list) by focusing on membership relationships for a given record.

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 when you need to know which lists contain a particular record, but it does not explicitly state when to use this tool versus alternatives (e.g., 'filter-list-entries' for filtering entries within a list, or 'search' for broader searches). No exclusions or prerequisites are mentioned.

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 a read operation ('Get details'), implying it's non-destructive, but fails to mention permissions, rate limits, error handling, or response format, which are critical for a tool with no structured safety hints.

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

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

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

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

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

Given the lack of annotations and output schema, the description is incomplete. It does not explain what 'details' are returned, error conditions, or behavioral traits, leaving significant gaps for a tool that retrieves specific member 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?

The input schema has 100% description coverage, with 'memberId' documented as 'The workspace member ID'. The description adds no additional meaning beyond this, so it meets the baseline for adequate but unenhanced parameter semantics.

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

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

The description clearly states the verb ('Get details') and resource ('workspace member'), making the purpose understandable. However, it does not differentiate from sibling tools like 'list-workspace-members' or 'search-workspace-members', which reduces 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 such as 'list-workspace-members' or 'search-workspace-members'. It lacks context about prerequisites or exclusions, leaving usage ambiguous.

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

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

Annotations already declare readOnlyHint=true and idempotentHint=true, so the agent knows this is a safe, repeatable read operation. The description adds context about supporting 'any record type' with examples, but doesn't disclose behavioral traits like pagination behavior (implied by limit/offset), rate limits, authentication needs, or what happens when no notes exist. With annotations covering safety, a 3 is appropriate.

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

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

The description is a single, efficient sentence that front-loads the core purpose. Every word earns its place by specifying the action ('Get'), resource ('notes'), and scope ('any record type') with clarifying examples. There's zero waste 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 read-only listing tool with good annotations (readOnlyHint, idempotentHint) and full schema coverage, the description is minimally adequate. However, without an output schema, it doesn't explain what the returned notes look like (structure, fields, ordering). The description covers the basic purpose but leaves return format unspecified, which is a gap given the tool's complexity.

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

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

Schema description coverage is 100%, so all parameters are documented in the schema. The description mentions 'any record type' which aligns with the resource_type enum, but adds no additional semantic context beyond what the schema provides. 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 tool's purpose as 'Get notes for any record type' with specific examples (companies, people, deals). It uses a specific verb ('Get') and resource ('notes'), but doesn't explicitly distinguish this from sibling tools like 'create-note' or 'search-by-content' which might also involve notes.

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

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

The description provides no guidance on when to use this tool versus alternatives. It doesn't mention sibling tools like 'search-by-content' (which might search note content) or 'create-note' (which creates notes), nor does it specify prerequisites or appropriate contexts for using this listing tool.

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

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

With no annotations provided, the description carries full burden for behavioral disclosure. It states it's a list operation but doesn't mention pagination behavior (implied by parameters), rate limits, authentication needs, or what the output looks like. The phrase 'for task assignment' adds some context but lacks operational details.

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

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

The description is a single, efficient sentence with no wasted words. It's front-loaded with the core purpose and includes a brief contextual note, making it appropriately sized and easy to parse.

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

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

For a list tool with no annotations and no output schema, the description is minimally adequate. It states the purpose but lacks details on output format, error handling, or behavioral constraints. The context 'for task assignment' adds some value, but more completeness would require explaining the return structure or usage nuances.

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 (page, pageSize, search). The description adds no additional parameter information beyond what's in the schema, meeting the baseline 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 verb ('List') and resource ('all workspace members'), providing a specific purpose. It adds context about 'for task assignment' which gives additional intent, though it doesn't explicitly differentiate from the sibling tool 'search-workspace-members' which might serve similar purposes.

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 'search-workspace-members' or 'get-workspace-member'. It mentions 'for task assignment' which implies a use case but doesn't specify prerequisites, exclusions, or comparison with 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 full burden for behavioral disclosure. It states the tool performs a removal operation but doesn't clarify if this is reversible, requires specific permissions, affects related data, or has side effects. For a mutation tool with zero annotation coverage, this leaves significant gaps in understanding its behavior.

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

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

The description is a single, efficient sentence that front-loads the core action and includes helpful examples without unnecessary elaboration. Every word earns its place, 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 insufficient. It lacks details on what happens after removal (e.g., confirmation message, error handling), whether the action is logged or reversible, and how it differs from similar tools. Given the complexity of list management in a CRM context, 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%, with both parameters ('entryId' and 'listId') clearly documented in the schema. The description doesn't add any parameter-specific details beyond what the schema provides, such as format examples or relationship context, so it meets the baseline for high schema coverage.

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

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

The description clearly states the action ('Remove') and target ('a company or person from a CRM list'), with examples of list types ('sales pipeline, lead list, etc.') that provide helpful context. It doesn't explicitly differentiate from sibling tools like 'delete-record' or 'update-list-entry', which would require 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?

No guidance is provided on when to use this tool versus alternatives like 'delete-record' (which might permanently delete) or 'update-list-entry' (which might modify rather than remove). The description mentions CRM lists but doesn't specify prerequisites, exclusions, or typical scenarios for removal.

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

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

Annotations indicate read-only and idempotent operations, which the description doesn't contradict. The description adds minimal behavioral context beyond annotations ('by query'), but doesn't cover important aspects like what data is searched, result format, or limitations. With annotations providing safety hints, the bar is lower, but the description could offer more operational details.

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 (one sentence) and front-loaded with the core function. However, the phrase 'for OpenAI MCP clients' is unnecessary clutter that doesn't help tool selection. Otherwise, it's efficiently structured with minimal waste.

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

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

Given the complexity of search operations, multiple sibling tools, and no output schema, the description is insufficient. It doesn't explain what 'Attio data' includes, how results are returned, or how this differs from other search tools. For a search tool in a crowded namespace, more context is needed to guide proper usage.

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

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

Schema description coverage is 100%, so parameters are well-documented in the schema itself. The description adds no parameter-specific information beyond implying a 'query' parameter exists. This meets the baseline of 3 when schema coverage is high, but doesn't enhance understanding of parameter usage or relationships.

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 tool searches Attio data by query, which provides a basic purpose. However, it's vague about what 'Attio data' encompasses and doesn't distinguish this tool from many sibling search tools (e.g., advanced-search, search-by-content, search-records). The phrase 'for OpenAI MCP clients' adds no functional clarity.

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 search tools (advanced-search, search-by-content, search-records, etc.), the description offers no context about differences in scope, performance, or use cases. It simply states what the tool does without comparative 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?

Annotations already declare readOnlyHint=true and idempotentHint=true, so the agent knows this is a safe, repeatable read operation. The description adds minimal behavioral context beyond this - it mentions the content types being searched but doesn't describe result format, pagination behavior, or any limitations. With annotations covering the safety profile, a 3 is appropriate as the description adds some value but not rich behavioral disclosure.

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 states the core function without unnecessary words. It's appropriately sized for a search tool, though it could be more front-loaded with distinguishing characteristics. There's no wasted verbiage, but it lacks the specificity that would make it truly excellent.

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 has 5 parameters, 100% schema coverage, and annotations declaring it as read-only/idempotent, the description is minimally adequate. However, without an output schema and with multiple similar sibling tools, the description should do more to clarify when this tool is appropriate versus alternatives. It meets minimum requirements but leaves significant contextual 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 all parameters are documented in the schema. The description mentions 'notes, activity, and interaction content' which partially maps to the content_type enum values, but doesn't add meaningful semantics beyond what the schema provides. The description doesn't explain parameter relationships or search behavior. Baseline 3 is correct 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 'Search within notes, activity, and interaction content' states the general action (search) and scope (content types), but it's vague about what resources are being searched. It doesn't distinguish from siblings like 'search', 'search-records', or 'advanced-search' which likely have overlapping functionality. The description provides basic purpose but lacks specificity about the target 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 multiple search-related siblings ('search', 'search-records', 'advanced-search', 'search-by-relationship', 'search-by-timeframe'), there's no indication of what makes this tool unique or when it's the appropriate choice. The description offers only a basic functional statement without usage context.

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

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

Annotations already declare readOnlyHint=true and idempotentHint=true, so the agent knows this is a safe, repeatable read operation. The description adds the core behavioral trait of relationship-based searching, which is valuable context beyond annotations. However, it doesn't describe pagination behavior, rate limits, or what happens when parameters are invalid, leaving some behavioral aspects unclear.

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

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

The description is a single, efficient sentence that states the core purpose without unnecessary words. It's front-loaded with the essential information and earns its place by clearly communicating the tool's unique approach to searching.

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

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

Given the tool's moderate complexity (6 parameters, relationship-based logic) and the absence of an output schema, the description is minimally adequate. It identifies the core concept but doesn't explain what the search returns, how results are structured, or provide examples of relationship queries. The 100% schema coverage helps, but for a relationship search tool, more contextual guidance 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%, with all 6 parameters well-documented in the schema itself. The description mentions 'relationships' which aligns with the 'relationship_type' parameter, but adds no additional semantic context beyond what the schema provides. With complete schema coverage, the baseline score of 3 is appropriate as 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 clearly states the tool's purpose: 'Search records by their relationships to other entities'. It specifies the verb ('search') and resource ('records') with the specific mechanism ('by their relationships'). However, it doesn't explicitly differentiate from sibling tools like 'search', 'search-by-content', or 'search-by-timeframe', which all perform different types of searches.

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

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

The description provides no guidance on when to use this tool versus alternatives. It doesn't mention sibling search tools like 'search', 'search-by-content', or 'search-by-timeframe', nor does it explain what makes relationship-based searching unique. The agent must infer usage from the description alone without explicit 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?

Annotations already declare readOnlyHint=true and idempotentHint=true, so the agent knows this is a safe, repeatable read operation. The description adds context about the temporal nature of the search but doesn't disclose additional behavioral traits like pagination behavior (implied by offset/limit), rate limits, authentication requirements, or what happens with empty results. It doesn't contradict annotations.

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

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

The description is a single, efficient sentence that immediately conveys the core functionality. It's appropriately sized for a search tool with good schema documentation, with zero 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?

Given the tool's moderate complexity (6 parameters, temporal filtering logic), 100% schema coverage, and read-only/idempotent annotations, the description is minimally adequate. However, without an output schema and with multiple similar search tools in the sibling set, it should provide more contextual differentiation and guidance about result format or when to prefer this over other search methods.

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 with descriptions, formats, enums, and constraints. The description adds minimal value beyond what's in the schema - it mentions 'temporal criteria' which aligns with timeframe_type but doesn't provide additional semantic 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 tool's purpose: 'Search records by temporal criteria' with specific examples of criteria types (creation, modification, interaction dates). It uses a specific verb ('Search') and resource ('records'), but doesn't explicitly distinguish it from sibling tools like 'search', 'search-by-content', or 'search-records' beyond the temporal focus.

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 multiple search-related sibling tools (search, search-by-content, search-by-relationship, search-records, advanced-search), there's no indication of when temporal filtering is preferred over other search methods or what distinguishes this from general search tools.

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

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

Annotations declare readOnlyHint=true and idempotentHint=true, indicating this is a safe, repeatable read operation. The description adds no behavioral context beyond what annotations provide—it doesn't mention pagination behavior, rate limits, authentication requirements, or what happens with empty results. However, it doesn't contradict the annotations either.

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 immediately conveys the core functionality without any wasted words. It's appropriately sized and front-loaded with the essential information about what the tool does.

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 complex search tool with 17 parameters, 100% schema coverage, and read-only/idempotent annotations, the description is minimally adequate. It states the purpose but lacks guidance on usage versus siblings, behavioral details, or output format (no output schema exists). The annotations provide safety context, but the description doesn't add enough value beyond the structured data.

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 17 parameters well-documented in the schema itself. The description adds no parameter-specific information beyond the general scope ('across all resource types'), which is already covered by the 'resource_type' parameter's enum. The baseline score of 3 is appropriate when the schema does all the heavy lifting.

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

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

The description clearly states the tool's purpose: 'Universal search across all resource types (companies, people, records, tasks)'. It specifies the verb ('search') and scope ('universal across all resource types'), but doesn't explicitly distinguish it from sibling tools like 'search', 'search-by-content', 'search-by-timeframe', or 'advanced-search', which appear to offer similar 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 multiple sibling search tools (e.g., 'search', 'search-by-content', 'search-by-timeframe', 'advanced-search'), the description fails to explain what makes this 'universal search' different or when it should be preferred over other search options.

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 search functionality but does not disclose behavioral traits such as permissions needed, rate limits, pagination, or response format. 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 no wasted words. It is appropriately sized and front-loaded, clearly stating the tool's purpose without unnecessary elaboration.

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

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

Given the lack of annotations and output schema, the description is incomplete. It does not explain return values, error conditions, or behavioral constraints, which are crucial for a search tool with no structured data to compensate.

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 'query' parameter. The description adds minimal value by specifying searchable attributes (name, email, role), but does not provide additional syntax or format details beyond the schema.

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

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

The description clearly states the verb ('Search') and resource ('workspace members'), specifying the searchable attributes (name, email, or role). However, it does not differentiate from sibling tools like 'list-workspace-members' or 'get-workspace-member', which reduces clarity about when to use this specific search tool.

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 siblings like 'list-workspace-members' and 'get-workspace-member', the description lacks context on use cases, prerequisites, or exclusions, leaving the agent to infer usage.

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 an update operation (implying mutation) but doesn't disclose permission requirements, whether changes are reversible, what happens to unspecified attributes, error conditions, or response format. The example adds some context about stage values but doesn't cover behavioral traits adequately 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 immediately conveys the core purpose with a helpful parenthetical example. Every word earns its place with zero redundancy or unnecessary elaboration, making it easy to parse while providing concrete context.

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 insufficient. It doesn't cover behavioral aspects like permissions, side effects, or response format, nor does it explain how this tool relates to sibling operations. The high schema coverage helps with parameters, but overall completeness is poor 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%, providing good documentation for all three parameters. The description adds minimal value beyond the schema: it mentions stage changes as an example, which aligns with the 'stage' property in the schema but doesn't explain parameter interactions or provide additional semantic context. 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 verb ('Update') and resource ('a list entry') with a specific example of changing stage values. It distinguishes the tool from siblings like 'update-record' by specifying it operates on list entries rather than general records. However, it doesn't explicitly contrast with all sibling tools that might modify list data.

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, when-not-to-use scenarios, or compare with sibling tools like 'update-record', 'add-record-to-list', or 'remove-record-from-list' that might handle related operations. The example is helpful but 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?

Annotations indicate this is a non-read-only, non-destructive operation, which the description's 'Update' action aligns with (no contradiction). The description adds minimal behavioral context beyond annotations—it mentions 'any supported type' but doesn't detail what happens on partial updates, error conditions, or side effects. With annotations covering safety, it meets baseline expectations without enriching 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 a single, efficient sentence that front-loads the core purpose with zero wasted words. It's appropriately sized for a tool with good schema coverage and annotations, making it easy to parse quickly 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 100% schema coverage and annotations, the description is minimally complete for a mutation tool. However, with no output schema and multiple parameters, it lacks details on return values, error handling, or operational constraints. It's adequate but leaves gaps that could hinder agent effectiveness in complex scenarios.

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

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

Schema description coverage is 100%, so parameters are fully documented in the schema. The description adds no additional meaning about parameters—it doesn't explain 'record_data' structure, 'resource_type' implications, or 'return_details' effects. Baseline score of 3 is appropriate as the schema carries the burden, but the description doesn't compensate with extra insights.

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 ('existing record of any supported type'), making the purpose immediately understandable. It distinguishes from siblings like 'create-record' (new vs existing) and 'delete-record' (update vs remove). However, it doesn't specify what 'update' entails operationally beyond the general concept.

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 record ID), compare to similar tools like 'update-list-entry' or 'batch-operations', or indicate scenarios where other tools might be more appropriate. Usage is implied but not explicitly defined.

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