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 creates a reservation but doesn't mention whether it requires permissions, what happens on conflicts, if it sends notifications, or what the response looks like. For a mutation tool with zero annotation coverage, this leaves critical behavioral traits undocumented.

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

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

The description is brief and front-loaded with the core purpose. The second sentence provides useful context about rooms and time intervals without redundancy. However, it could be more structured by separating room listing from time slot information for better readability.

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

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

For a mutation tool with no annotations and no output schema, the description is incomplete. It doesn't cover error conditions, response format, authentication needs, or interaction with sibling tools. Given the complexity of creating reservations and the lack of structured data, more contextual information is needed.

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

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

Schema description coverage is 100%, so the schema fully documents all parameters. The description adds minimal value by listing room names (already in the enum) and noting time slots are in 30-minute intervals (implied by schema patterns but not explicitly stated). This meets the baseline for high schema coverage without significant enhancement.

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

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

The description clearly states the action ('Create a new room reservation') and specifies the resource ('room reservation'), distinguishing it from sibling tools like delete_reservation or update_reservation. It provides specific context about available rooms and time slot intervals, making the purpose explicit and actionable.

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 update_reservation or get_available_rooms. It lists available rooms but doesn't mention prerequisites (e.g., authentication), conflicts with other reservations, or when to choose this over other reservation-related tools.

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

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

With no annotations provided, the description carries the full burden of behavioral disclosure. It mentions the ownership restriction, which is valuable context beyond basic functionality. However, it lacks critical details: whether deletion is permanent/reversible, what happens to associated data, error conditions, or response format. For a destructive operation with zero annotation coverage, this leaves significant gaps.

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

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

The description is extremely concise with just two sentences that each earn their place: the first states the core action, and the second adds crucial usage context. There's zero wasted language, and the most important information (the action) is front-loaded.

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

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

Given this is a destructive operation with no annotations and no output schema, the description is incomplete. It mentions the ownership restriction but omits other critical behavioral aspects (permanence, side effects, response format). For a tool that permanently removes data, more context about consequences and results is needed.

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

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

The input schema has 100% description coverage, with the parameter 'reservationId' fully documented in the schema itself. The description adds no additional parameter information beyond what's already in the schema (e.g., no extra syntax or format details). According to the rules, when schema_description_coverage is high (>80%), the baseline is 3 even with no param info in the description.

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

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

The description clearly states the action ('Delete') and resource ('a reservation'), making the purpose immediately understandable. It distinguishes itself from sibling tools like 'update_reservation' by specifying deletion rather than modification. However, it doesn't explicitly contrast with other deletion-related tools (none exist in siblings), so it's not a perfect 5.

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

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

The description provides clear context for when to use this tool: 'Only the owner of the reservation can delete it.' This establishes an important prerequisite. However, it doesn't explicitly mention when NOT to use it (e.g., vs. 'update_reservation' for modifications) or name specific alternatives, keeping it from a score of 5.

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

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

No annotations are provided, so the description carries the full burden. It states the tool retrieves a list, implying a read-only operation, but doesn't disclose behavioral traits such as whether it requires authentication, has rate limits, returns paginated results, or includes metadata like room capacities. This leaves significant gaps for a tool in a reservation system.

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

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

The description is a single, efficient sentence that directly states the tool's purpose without unnecessary words. It is front-loaded and wastes no space, making it highly concise and well-structured.

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

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

Given the complexity of a room reservation system, no annotations, and no output schema, the description is incomplete. It doesn't explain what 'available' means (e.g., time-based, capacity-based), the format of the returned list, or how it interacts with sibling tools. This leaves the agent with insufficient context for effective use.

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

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

The input schema has 0 parameters with 100% coverage, so no parameter documentation is needed. The description doesn't add parameter details, but this is appropriate given the schema completeness. A baseline of 4 is applied as it adequately handles the lack of parameters without introducing confusion.

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 ('list of all available rooms/spaces'), making the purpose understandable. However, it doesn't differentiate from sibling tools like 'get_room_availability' or 'get_reservations_by_room', which appear related to room/availability queries, so it doesn't reach the highest 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 'get_room_availability' or 'get_reservations_by_room'. It mentions 'can be reserved' which hints at a reservation context, but lacks explicit when/when-not instructions or named alternatives.

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

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

With no annotations provided, the description carries full burden but only states what the tool does without disclosing behavioral traits. It doesn't mention whether this is a read-only operation, potential rate limits, authentication needs, or what happens if no data exists for the date. For a tool with zero annotation coverage, 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?

Two sentences that are front-loaded with the core purpose and efficiently specify scope. Every word earns its place with no redundancy or unnecessary elaboration.

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

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

Given the tool's moderate complexity (single parameter, read operation implied), no annotations, and no output schema, the description is minimally adequate but incomplete. It explains what the tool returns conceptually but not the structure or format of the overview data, leaving gaps for the agent to infer.

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

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

The schema description coverage is 100%, with the single parameter 'date' fully documented in the schema. The description adds no additional parameter semantics beyond implying the date is used to filter reservations, which is already clear from the schema. Baseline 3 is appropriate when schema does the heavy lifting.

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

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

The description clearly states the verb ('Get') and resource ('complete overview of all rooms and their reservations'), specifying it's for a given date and shows every room with booked slots. It distinguishes from siblings like get_available_rooms (which likely shows availability rather than reservations) and get_reservations (which might list reservations without room context).

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

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

The description implies usage when needing a comprehensive view of room bookings for a specific date, but doesn't explicitly state when to use this tool versus alternatives like get_reservations_by_room or get_room_availability. 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 this is a read operation ('Get'), implying it's likely non-destructive, but doesn't mention error handling (e.g., what happens if the ID is invalid), authentication needs, rate limits, or response format. This leaves significant gaps for a tool with no annotation coverage.

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

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

The description is a single, efficient sentence with zero waste—it directly states the tool's purpose without unnecessary words. It's appropriately sized and front-loaded, making it easy to parse quickly.

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

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

Given the lack of annotations and output schema, the description is incomplete. It doesn't explain what the tool returns (e.g., reservation details), error conditions, or behavioral traits like idempotency. For a read tool with no structured data support, this leaves the agent under-informed about key operational aspects.

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

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

The schema description coverage is 100%, with the parameter 'reservationId' fully documented as a UUID in the schema. The description adds no additional meaning beyond what the schema provides (e.g., it doesn't clarify where to find the ID or provide examples), so it meets the baseline score of 3 for high schema coverage.

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

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

The description clearly states the verb ('Get') and resource ('a single reservation by its ID'), making the purpose specific and understandable. However, it doesn't explicitly differentiate from sibling tools like 'get_reservations' (plural) or 'get_reservations_by_room', which might cause confusion in selection.

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 'get_reservations' or 'get_reservations_by_room'. It lacks context about prerequisites (e.g., needing a reservation ID) or exclusions, leaving the agent to infer usage from the name alone.

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

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

No annotations are provided, so the description carries full burden. It states the tool gets reservations with optional filtering, but doesn't disclose behavioral traits such as whether it's read-only, pagination behavior, rate limits, authentication needs, or what happens if no date is provided (though implied by 'returns all reservations'). This leaves significant gaps for a tool that likely interacts with reservation data.

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

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

The description is a single, efficient sentence that front-loads the core purpose ('Get all room reservations') and adds optional filtering information. 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 no annotations, no output schema, and a simple input schema, the description is minimally adequate but incomplete. It covers the basic purpose and parameter implication, but lacks details on behavior, output format, error handling, or sibling tool differentiation, which are important for effective use in this context with multiple related tools.

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

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

Schema description coverage is 100%, so the schema fully documents the single parameter 'date' with its format and default behavior. The description adds no additional parameter semantics beyond what's in the schema, such as examples or edge cases, meeting the baseline for high schema coverage.

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

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

The description clearly states the verb 'Get' and resource 'room reservations' with optional date filtering. It distinguishes from siblings like 'get_reservation' (singular) and 'get_reservations_by_room/user' by not specifying filtering by room or user, but doesn't explicitly contrast with 'get_day_overview' or 'get_available_rooms' 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 implies usage when needing all reservations with optional date filtering, but doesn't explicitly state when to use this versus alternatives like 'get_reservations_by_room' or 'get_day_overview'. No guidance on prerequisites or exclusions is provided.

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

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

With no annotations provided, the description carries full burden but only states the basic operation. It doesn't disclose behavioral traits like whether this is a read-only operation (implied but not stated), potential rate limits, authentication requirements, pagination behavior, error conditions, or response format. For a tool with zero annotation coverage, this is insufficient.

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

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

The description is a single, efficient sentence that front-loads the core purpose ('Get all reservations for a specific room') and adds qualifying information ('optionally filtered by date'). Every word earns its place with zero redundancy.

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

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

Given no annotations and no output schema, the description provides adequate basic purpose but lacks important context about behavior, response format, and operational constraints. For a read operation with 2 parameters, it's minimally viable but leaves significant gaps in understanding how to properly use and interpret results.

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

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

Schema description coverage is 100%, with both parameters well-documented in the schema. The description adds minimal value beyond the schema by mentioning the optional date filter, but doesn't provide additional semantic context about parameter usage or constraints. Baseline 3 is appropriate when schema does the heavy lifting.

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

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

The description clearly states the specific action ('Get all reservations') and target resource ('for a specific room'), with additional scope details ('optionally filtered by date'). It distinguishes from siblings like 'get_reservations' (general) and 'get_reservations_by_user' (different filter).

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

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

The description implies usage context by specifying 'for a specific room' and 'optionally filtered by date', helping differentiate from 'get_reservations' (no room filter) and 'get_room_availability' (availability vs. reservations). However, it doesn't explicitly state when NOT to use it or name alternatives.

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

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

With no annotations provided, the description carries the full burden. It implies a read-only operation ('Get') and specifies default behavior for the userId parameter, but doesn't disclose other behavioral traits like pagination, error handling, or authentication requirements beyond the default. It adds some context but is incomplete for a tool with no 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 two sentences, front-loaded with the core purpose and followed by a key behavioral detail (default). Every word earns its place with no redundancy or fluff, making it highly efficient.

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

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

Given the tool's low complexity (1 optional parameter, no output schema, no annotations), the description is adequate but has gaps. It covers the purpose and default behavior, but lacks details on return format (e.g., list structure) or error cases, which could be helpful for an agent despite the simple schema.

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

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

The schema description coverage is 100%, so the schema already documents the userId parameter fully. The description adds marginal value by reinforcing the default behavior, but doesn't provide additional semantics beyond what's in the schema. With 0 parameters effectively (since it's optional with a default), this exceeds the baseline of 3.

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

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

The description clearly states the action ('Get all reservations') and the target ('for a specific user'), distinguishing it from siblings like 'get_reservations' (general) or 'get_reservations_by_room' (room-specific). It specifies the verb and resource precisely.

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

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

The description provides clear context by stating it defaults to the authenticated user, which helps understand when to use it (for user-specific queries). However, it doesn't explicitly mention when not to use it or name alternatives like 'get_reservation' (single) or 'get_reservations' (all), so it lacks full sibling differentiation.

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 retrieves schedule information ('showing all booked time slots'), implying a read-only operation, but does not address potential behaviors like error handling (e.g., invalid dates), rate limits, authentication needs, or output format details (e.g., time slot structure). This leaves significant gaps for a tool with no annotation support.

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

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

The description is a single, efficient sentence that front-loads the core purpose ('Get the schedule for a specific room on a given date') and adds clarifying detail ('showing all booked time slots'). There is no wasted text, 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 moderate complexity (2 required parameters, no output schema, no annotations), the description is minimally adequate. It covers the basic purpose but lacks details on behavioral traits, usage context, and output format. Without annotations or an output schema, the agent must rely heavily on the description, which is incomplete for safe and effective use.

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

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

The schema description coverage is 100%, with clear descriptions for both parameters (roomId and date). The description adds no additional parameter semantics beyond what the schema provides, such as explaining the significance of room names or date constraints. With high schema coverage, the baseline score of 3 is appropriate, as the description does not compensate but also does not detract.

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

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

The description clearly states the tool's purpose: 'Get the schedule for a specific room on a given date, showing all booked time slots.' It specifies the verb ('Get'), resource ('schedule for a specific room'), and scope ('on a given date'), but does not explicitly differentiate it from siblings like 'get_reservations_by_room' or 'get_day_overview', which might offer overlapping 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. It does not mention sibling tools like 'get_available_rooms' (for finding free rooms) or 'get_reservations_by_room' (which might list reservations for a room without date filtering), leaving the agent to infer 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?

No annotations are provided, so the description carries the full burden of behavioral disclosure. While it mentions the default behavior (authenticated user if no ID), it lacks critical information: authentication requirements, rate limits, error handling (e.g., what happens with invalid IDs), or response format. For a read operation with zero annotation coverage, this leaves significant gaps in understanding how the tool behaves beyond its 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 front-loads the core purpose ('Get a user profile by ID') and follows with essential context ('Defaults to the authenticated user'). There is no wasted language, and every word earns its place, making it highly concise and well-structured for quick comprehension.

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

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

Given the tool's low complexity (one optional parameter) and high schema coverage (100%), the description is minimally adequate. However, with no annotations and no output schema, it fails to address key behavioral aspects like authentication, errors, or return values. The description covers the basic use case but leaves gaps that could hinder an agent's ability to invoke the tool correctly in all 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%, with the parameter 'userId' fully documented in the schema (including type, format, and default behavior). The description adds no additional parameter semantics beyond what the schema already provides—it merely restates the default behavior. According to the rules, when schema coverage is high (>80%), the baseline is 3 even without extra param info in the description.

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

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

The description clearly states the verb ('Get') and resource ('user profile by ID'), making the purpose immediately understandable. It distinguishes this tool from sibling tools like 'get_user_profiles' (plural) and 'search_user' by specifying retrieval of a single profile by ID rather than multiple profiles or search functionality. However, it doesn't explicitly contrast with all siblings, so it falls short of 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 clear context for when to use this tool: to retrieve a user profile by ID, with the default behavior of returning the authenticated user's profile if no ID is provided. This helps differentiate it from 'get_user_profiles' (which likely returns multiple profiles) and 'search_user' (which likely involves query parameters). However, it doesn't explicitly state when NOT to use it or name specific alternatives, preventing a score of 5.

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 the tool is 'useful for resolving emails,' hinting at return content, but doesn't disclose key behaviors: whether it's read-only, how it handles invalid IDs, if results are paginated, or error conditions. For a tool with no annotation coverage, this leaves significant gaps.

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

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

The description is concise and front-loaded: the first sentence states the core purpose, and the second adds context. Both sentences earn their place by clarifying scope and utility, with no redundant or vague phrasing.

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 moderately complete for a simple lookup tool. It covers the purpose and hints at use cases but lacks details on return values, error handling, or behavioral constraints. This is adequate but has clear gaps for an agent to rely on.

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

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

Schema description coverage is 100%, so the schema fully documents the 'userIds' parameter (array of UUIDs, minItems: 1). The description adds minimal value beyond this, only implying the IDs come from 'reservation user_ids.' No additional syntax or format details are provided, aligning with the baseline score 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 tool's purpose: 'Get multiple user profiles by their IDs.' This specifies the verb ('Get') and resource ('user profiles'), and distinguishes it from the sibling 'get_user_profile' (singular) by indicating it handles multiple IDs. However, it doesn't explicitly contrast with 'search_user' for broader lookups.

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 implied usage context: 'Useful for resolving emails from reservation user_ids' suggests it's for batch lookups tied to reservations. It doesn't explicitly state when to use this vs. 'get_user_profile' (single) or 'search_user' (query-based), nor does it mention prerequisites or exclusions.

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

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

With no annotations provided, the description carries full burden for behavioral disclosure. It only describes the search functionality without mentioning important behavioral aspects like authentication requirements, rate limits, result format, pagination, case sensitivity, or what happens when no matches are found.

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

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

The description is perfectly concise - a single sentence that communicates the essential functionality without any wasted words. It's front-loaded with the core purpose and includes the key detail about partial email matching.

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 no annotations and no output schema, the description is insufficient. It doesn't explain what the search returns (user objects, IDs, limited fields), how results are structured, or any behavioral constraints. The context signals show this is a simple single-parameter tool, but the description should still address basic behavioral expectations.

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

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

The schema description coverage is 100%, so the schema already documents the single 'email' parameter completely. The description adds marginal value by reinforcing that both exact and partial email matching is supported, but doesn't provide additional semantic context beyond what's in the schema.

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

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

The description clearly states the tool's purpose as searching for users using email criteria. It specifies both exact email and partial email matching, which adds useful detail. However, it doesn't distinguish this tool from potential sibling search tools (though none exist in the provided list).

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

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

The description provides no guidance about when to use this tool versus alternatives. It doesn't mention whether this is the primary user lookup method, when to use it versus get_user_profile/get_user_profiles, or any prerequisites or constraints 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?

With no annotations provided, the description carries the full burden of behavioral disclosure. It states the tool updates an existing reservation, implying mutation, but lacks details on permissions required, whether changes are reversible, error handling (e.g., if room is unavailable), or response format. This is a significant gap for a mutation tool with zero annotation coverage.

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

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

The description is a single, efficient sentence that front-loads the core purpose ('Update an existing reservation') and adds specific details ('room, time, or date') without redundancy. Every word earns its place, 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 mutation tool with no annotations and no output schema, the description is incomplete. It lacks behavioral context (e.g., side effects, error conditions), usage guidelines, and details on return values. While the schema covers parameters well, the overall context for safe and effective use is insufficient.

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

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

The description mentions 'room, time, or date' as updatable fields, which partially maps to parameters like roomId, startTime, endTime, and date. However, with 100% schema description coverage, the schema already documents all parameters thoroughly. The description adds minimal value beyond the schema, meeting the baseline of 3 for high coverage.

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

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

The description clearly states the action ('Update') and resource ('an existing reservation'), specifying what can be changed ('room, time, or date'). It distinguishes from siblings like create_reservation and delete_reservation by focusing on modifications rather than creation or deletion, though it doesn't explicitly mention all siblings.

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 reservationId), exclusions (e.g., what cannot be updated), or comparisons to siblings like create_reservation or delete_reservation, leaving the agent to infer usage from context alone.

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