lacita

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

Annotations indicate a non-read-only, non-destructive operation. The description adds value by disclosing the maximum of 5 reminders per calendar and the two modes (relative/specific_time), which are behavioral constraints not visible in annotations. It does not 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 two sentences, front-loaded with the primary purpose, and every clause contributes meaningful information (types, limit). No wasted words.

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

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

The description covers the essential behavior (add reminder, two types, max 5) and the schema documents all parameters. While it doesn't explain success/error responses, that is not required given no output schema, and the operation's scope is simple enough.

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

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

Schema coverage is 100%, so the baseline is 3. The description reinforces the meaning of the reminder types but does not add new details about conditional dependencies or parameter formats beyond what the schema already 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 action ('Add a reminder configuration to a calendar') with a specific verb and resource. It distinguishes the tool from siblings by specifying the two reminder types and the limit of 5, making it unambiguous.

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

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

The description implies usage by explaining the two supported reminder types and the max limit. It does not explicitly name alternatives, but the context is clear and there are no exclusions; the sibling tools naturally indicate when this is the add operation vs. delete/get.

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 disclose destructive/non-read-only behavior; description adds the 'full scope' authorization requirement, which is useful beyond structured fields. It does not 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?

Two concise sentences with essential info front-loaded; no filler.

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

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

For a simple two-param cancellation tool, description plus annotations and schema sufficiently cover purpose, required auth, and destructive nature. No output schema, but return values are not critical here; minor gap in not mentioning post-cancellation effects.

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

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

Schema covers both parameters with descriptions (100% coverage), so description needn't elaborate. 'Requires full scope' is not parameter-specific; reason and appointmentId are adequately defined in 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?

Description uses specific verb 'Cancel' and resource 'existing appointment', clearly indicating the action. It doesn't explicitly distinguish from sibling 'reschedule_appointment', but purpose is unambiguous.

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

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

No guidance on when to prefer cancellation over alternatives like reschedule_appointment, nor any exclusions. 'Requires full scope' is a prerequisite, not 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 already indicate readOnlyHint=false and destructiveHint=false, so the description is not required to restate safety. However, it adds little beyond the schema: 'optional settings' is already evident from the input schema. It does not disclose side effects (e.g., whether creation requires authentication, whether it overwrites anything, or what happens on duplicate names).

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

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

The description is one short, direct sentence that front-loads the primary action. It contains no filler or redundant information, and every word earns its place.

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

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

Given the tool has 10 parameters and no output schema, the description is somewhat sparse. It doesn't mention the return value (e.g., created calendar object) or any behavioral implications of the settings. However, the schema covers parameter semantics well, so the missing return-value note is a gap but not catastrophic.

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

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

Schema description coverage is 100%, with each parameter having a descriptive comment. The description's phrase 'optional settings' adds no specific semantics beyond what the schema already provides, so the baseline of 3 is appropriate; it does not compensate or add additional meaning.

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

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

The description 'Create a new booking calendar with optional settings' uses a specific verb ('create') and resource ('booking calendar'), clearly distinguishing it from sibling tools like create_calendar_override or create_contact. It accurately conveys the core action.

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 a new calendar) but gives no explicit when-to-use vs alternatives, no exclusions, and no prerequisites. It doesn't mention that this is for initial calendar setup, while update_calendar would be for modifying an existing one, which would be useful 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 show this is a non-read-only, non-destructive operation. The description adds the key behavioral distinction between blocking a day and modifying hours, but does not disclose edge cases like what happens when an override already exists for the date or permission requirements.

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

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

The description is a single sentence that fully captures the core action and use cases. No redundant wording or filler.

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 create operation with 6 parameters and no output schema, the description covers the essential purpose and examples. It is slightly incomplete regarding preconditions (e.g., whether an override on the same date is replaced) and success behavior, but schema and annotations cover most of the remaining context.

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

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

Schema description coverage is 100%, so parameters are fully documented. The description adds no new parameter-level details beyond the schema, but the examples ('block a day off or modify hours') map to the isBlocked, startTime, and endTime parameters, providing a minor semantic cue.

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 creates an availability override for a specific date, with concrete examples (block a day off or modify hours). This distinguishes it from sibling tools like delete_calendar_override or get_calendar_overrides.

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

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

The description implies usage for date-specific availability changes but does not explicitly mention when to use this over alternatives such as update_calendar_weekly_availability or delete_calendar_override. No exclusions or alternative tool references are provided.

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

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

Annotations already indicate a write operation (readOnlyHint=false). The description adds 'Requires write scope,' which is useful authentication context. It does not disclose other behaviors such as error cases or idempotency, but these are partially covered by annotations (idempotentHint=false). No contradictions 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 extremely concise — two short phrases that convey the core purpose and a key requirement. Every word earns its place, with no redundancy or filler.

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 simple tool complexity, complete schema coverage, and available annotations, the description is mostly sufficient. It lacks mention of return values (no output schema), but this is a minor gap for a straightforward create operation. The write scope note adds useful context.

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

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

Schema description coverage is 100%, so all parameters (email, phone, lastName, firstName) are already documented in the schema. The description adds no additional parameter-level meaning, matching 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 'Create a new contact' with a specific verb and resource, distinguishing it from sibling tools like update_contact and delete_contact. The purpose is immediately obvious.

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 that this is for new contacts only, nor does it reference update_contact for existing contacts. The only hint is 'Requires write scope,' which is a permission note, not 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?

Beyond annotations, the description adds critical behavioral details: the action is irreversible, it cascades to delete all appointments, and full scope is required. This goes well beyond the destructiveHint annotation and provides meaningful side-effect context.

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

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

Three short sentences, front-loaded with the action, then scope and irreversibility. Every sentence earns its place with no filler 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 single-parameter delete operation, the description covers what is deleted, the cascade behavior, irreversibility, and a scope requirement. Annotations provide the destructive hint, and no output schema is expected, so the description is complete.

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

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

The input schema already describes calendarId with 100% coverage. The tool description adds no additional parameter-level meaning, so the baseline 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 uses the specific verb 'Delete' and clearly identifies the resource 'calendar' plus the added scope 'and all its appointments'. This distinguishes it from sibling tools like delete_calendar_override or delete_calendar_reminder.

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 clearly indicates when to use this tool (to delete a calendar and its appointments). It does not explicitly mention alternatives or exclusions, but the 'Requires full scope' note provides a clear prerequisite. Lacks explicit when-not guidance compared to a top-tier example.

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

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

The description says 'Delete' which is a destructive action, but the annotations declare destructiveHint=false. This is a direct contradiction. Additionally, the description provides no context about irreversibility, permissions, or effects on related data. The contradiction alone forces a score of 1.

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

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

The description is a single sentence with no wasted words, front-loading the core action. However, it is so minimal that it provides little information, though for a simple delete tool this is adequate. Not a 5 because it lacks any helpful 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?

This is a destructive operation with no annotations, no output schema, and a very short description. It fails to disclose that deletion is permanent, what happens to associated events, or any edge cases. The low complexity does not compensate for the lack of critical 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 for both parameters (calendarId and overrideId). The description adds no extra meaning beyond what the schema already provides, so the baseline of 3 applies.

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 exact action ('Delete') and resource ('an availability override'), which clearly distinguishes it from sibling tools like create_calendar_override or get_calendar_overrides. Even without the tool name, the purpose is unambiguous.

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

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

No guidance is provided on when to use this tool versus alternatives. There is no mention of prerequisites, when deletion is appropriate, or any excluded scenarios. The only usage context is implicit from the tool name and sibling names.

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

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

The description contradicts the annotations: destructiveHint is false while the description explicitly states 'Delete', which is inherently destructive. No additional behavioral context is provided beyond the structured annotations, making this a serious inconsistency.

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

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

The description is a single, concise sentence that is front-loaded with the key action and resource, with no wasted words.

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

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

The tool is simple, but the description does not explain the effects of deletion (e.g., irreversibility, failure behavior), and the contradiction between annotations and description undermines completeness. Without this context, an agent cannot fully assess the operation's consequences.

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?

Both parameters (calendarId, reminderId) are fully described in the schema with 100% coverage. The description adds no extra meaning beyond the schema, which already documents the parameter purposes.

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 the target resource (a reminder configuration from a calendar), using a specific verb that distinguishes it from sibling tools like add_calendar_reminder, get_calendar_reminders, and delete_calendar_override.

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

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

No guidance is provided on when to use this tool versus alternatives. It does not mention prerequisites, conditions, or exclusions, so the agent is left without context for selecting this tool over similar delete 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 destructiveHint=true, readOnlyHint=false, and idempotentHint=false. The description adds the context that full scope is required, which is useful beyond the annotations. It does not contradict any annotation.

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

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

The description is extremely concise at two short phrases. 'Delete a contact' is redundant with the name but 'Requires full scope' adds valuable context. Every word earns its place.

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

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

Given the tool's low complexity (one parameter, no output schema) and strong annotations covering destructive behavior, the description is nearly complete. The 'full scope' requirement adds an important operational constraint. It could mention side effects or error behavior, but this is not critical for such a simple delete operation.

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

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

The input schema has 100% coverage for the single parameter contactId with description 'The contact ID'. The tool description adds no additional parameter semantics, so the baseline score of 3 applies.

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

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

The description 'Delete a contact' uses a specific verb and resource, clearly distinguishing it from sibling tools like create_contact, update_contact, and get_contact. It precisely states the operation performed.

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 does not provide any guidance on when to use this tool versus alternatives. 'Requires full scope' is a prerequisite, not a usage guideline, and no exclusions or alternative tool references are given.

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

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

The annotations already disclose readOnly, idempotent, openWorld, and non-destructive behavior, so the description does not need to repeat these. It adds no further behavioral traits such as error handling, authentication, or response specifics, but it also does not contradict the 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 sentence that is front-loaded with the action and resource, contains no filler, and every word contributes to the purpose. It is appropriately minimal for a straightforward getter.

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

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

For a simple single-parameter tool with rich annotations, the description is adequate for an agent to select and invoke it correctly. It lacks explicit output structure, but the phrase 'detailed information' plus the domain context is sufficient given the absence of an output 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 input schema has 100% description coverage for appointmentId ('The appointment ID'), so the description adds no additional semantic value beyond what the schema already provides. The baseline of 3 applies.

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

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

The description uses a specific verb 'Get' and identifies the resource 'appointment' with the scope 'specific', clearly distinguishing it from the sibling get_appointments (plural). The phrase 'detailed information' conveys what the operation returns, making the purpose unmistakable.

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 usage is implied: use this when you need details about a single appointment by ID. However, the description provides no explicit guidance on when to prefer this over get_appointments or any alternative, nor does it mention exclusions or prerequisites.

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

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

The annotations (readOnlyHint=true, destructiveHint=false, openWorldHint=true, idempotentHint=true) already convey that this is a safe, non-mutating read operation. The description adds the filtering capabilities by status and date, which is useful context. However, it does not disclose potential pagination behavior, default limits, or whether all appointments are returned when no filters are applied. As with the get_calls calibration, the annotations cover the safety profile, and the description provides some but not rich behavioral context.

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

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

The description is a single, front-loaded sentence: 'List appointments with optional filtering by status and date.' Every word is meaningful and there is no waste. It immediately states the action and resource, then adds the key optional modifiers, making it efficient 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?

The tool has 4 optional parameters and no output schema, but the annotations are rich and the schema descriptions are fairly complete. The description covers the core function and filtering options, but it does not explain what happens with no filters (e.g., returns all appointments), address pagination, or mention the return format. For a list tool, this is adequate but not fully complete, especially without an output schema to fall back 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 75% (status lacks a textual description but has an enum). The description mentions 'status and date' as filtering options, which groups 'status', 'from', and 'to' semantically, but does not add detail beyond what the schema already provides for these parameters. The 'limit' parameter is not mentioned in the description, but the schema describes it as 'Maximum number of results'. Overall, the description adds minimal value beyond the schema, so a baseline 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 uses a specific verb ('List') and resource ('appointments'), clearly indicating a read operation that returns multiple records. It also mentions optional filtering by status and date, which distinguishes it from the sibling tool 'get_appointment' (singular) and implies a broader scope. The purpose is unambiguous and well-differentiated.

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

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

No explicit guidance is given on when to use this tool versus alternatives. While the plural 'appointments' and 'List' imply it is for retrieving multiple records, there is no mention of when to choose this over 'get_appointment' or 'get_calendar_availability'. The description does not exclude any scenarios or state prerequisites, so the agent is left 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?

Annotations already declare readOnlyHint, openWorldHint, idempotentHint, and non-destructive. The description adds that the return includes 'all settings,' which gives useful context about response content. However, it doesn't elaborate on pagination, authentication, or other behavioral details. With good annotation coverage, this is adequate but not exceptional.

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

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

The description is a single sentence, front-loaded with the action ('Get') and resource, and contains no filler. It conveys the core purpose efficiently.

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

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

For a simple 1-parameter read-only tool with strong annotations, the description is sufficient. It indicates the scope and that settings are included, but could be slightly more explicit about the nature of the 'detailed information.' However, given the low complexity and annotation coverage, this is nearly complete.

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

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

Schema coverage is 100% for the single parameter 'calendarId,' described as 'The calendar ID.' The description mentions 'specific calendar' which aligns with the parameter, but it does not add format, examples, or source instructions beyond the schema. 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 uses the verb 'Get' with a specific resource: 'detailed information about a specific calendar including all settings.' It clearly distinguishes from sibling tool get_calendars by scope ('specific calendar' vs. list) and adds detail about the return content ('including all settings').

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 context is clear: use this when you need detailed information about one specific calendar, including its settings. It doesn't explicitly mention alternatives or exclusions, but the sibling names and the 'specific' wording make the intended use evident. Lacks explicit 'when not to use' guidance.

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

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

Annotations already declare readOnlyHint=true and idempotentHint=true, so the description does not need to cover safety. The description adds the scoping to a specific calendar and date but does not disclose other behavioral traits like timezone handling or how availability is determined, which is acceptable given the 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 concise sentences, front-loaded with the primary purpose and followed by a practical usage hint. There is no redundant wording or unnecessary detail.

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

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

For a simple read-only lookup tool with rich annotations and a clear description of the return value ('available time slots'), the description is complete. The absence of an output schema is mitigated by the unambiguous phrasing, and the annotations cover safety 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 input schema already provides descriptions for all three parameters (calendarId, date, timezone), so schema coverage is 100%. The description only mentions 'specific calendar' and 'given date', adding no new meaning beyond the schema, hence the baseline score 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 tool retrieves available time slots for a specific calendar on a given date, using a specific verb and resource. It distinguishes from the sibling tool get_calendar_weekly_availability by limiting to a single date.

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

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

The description provides a clear usage context: 'Use this to check what times are open for booking.' However, it does not explicitly mention when not to use it or name alternatives like the weekly availability tool, so it falls short of a perfect score.

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, openWorldHint, idempotentHint, and destructiveHint, so the safety profile is known. The description adds context on what overrides mean (modified or blocked availability), which enriches the agent's understanding of the returned data without contradicting 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 sentence that is clear and front-loaded with the action ('Get availability overrides'). It contains no extraneous information and is appropriately concise.

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?

This is a simple read-only tool with one parameter and rich annotations. The description adequately explains what the tool returns, and no output schema is present. The information provided is sufficient for an agent to select and invoke the tool correctly.

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

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

The schema covers the only parameter (calendarId) with a description, and the coverage is 100%. The tool description does not add additional parameter semantics, but since the schema already handles it, the baseline score of 3 applies.

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 retrieves availability overrides for a calendar, with a parenthetical clarifying that overrides are specific dates with modified or blocked availability. This distinguishes it from siblings like get_calendar_availability and get_calendar_weekly_availability by focusing on overrides.

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 does not explicitly state when to use this tool versus alternatives, nor does it provide exclusions. The use case is implied through the term 'overrides,' but there is no direct comparison to sibling tools such as get_calendar_availability or get_calendar_weekly_availability.

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, openWorldHint=true, idempotentHint=true, and destructiveHint=false, providing strong safety coverage. The description adds the domain constraint that each calendar can have up to 5 reminders, which is not in annotations, but it does not discuss return format or edge cases. This adds modest value beyond 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 only two sentences, with the main purpose in the first sentence and a brief relevant domain note in the second. No redundant or filler content.

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

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

For a simple read-only tool with rich annotations and a single well-documented parameter, the description sufficiently explains purpose and a key behavioral constraint. It lacks an output schema, but 'all reminder configurations' implies a list return, making it complete for its 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?

The schema fully documents the calendarId parameter with 100% coverage, so the description adds no additional parameter-level meaning. The baseline of 3 is appropriate since the schema handles all 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 'Get all reminder configurations for a calendar' with a specific verb and resource, scoped to a calendar. It distinguishes itself from sibling tools like get_calendar, get_calendar_overrides, and add/delete_calendar_reminder by focusing on reminder configurations.

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 the tool is for reading reminder configurations but does not explicitly mention when to use it versus alternatives like add_calendar_reminder or delete_calendar_reminder. There are no exclusion statements or named alternatives, so usage is implied but not directly guided.

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 provide readOnlyHint=true and destructiveHint=false, so the description adds value by specifying the return shape (array of calendars with settings like remindersEnabled, duration, buffers). This goes beyond annotations with useful behavioral context.

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

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

Two sentences, front-loaded with the purpose, then return details. No wasted words or redundancy.

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

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

Given zero parameters, no output schema, and strong annotations, the description fully covers what the tool does, the ownership scope, and the return contents. It is complete for its 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?

No parameters exist, so the schema is trivially covered. The description doesn't need to add parameter detail, and the baseline for 0 params is 4.

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' with resource 'booking calendars' and scope 'owned by the user'. This distinguishes it from singular get_calendar and other calendar sub-resource tools.

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

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

It clearly implies use when you want all calendars owned by the user, and the plural 'all' distinguishes from singular retrieval. However, it does not explicitly name alternatives or exclusions for specific sub-resources like availability or reminders.

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 read-only nature is covered. The description adds a bit of behavioral context by clarifying that the tool returns recurring slots per day, but it does not disclose additional traits such as timezone behavior, how overrides are handled, or whether booked appointments affect the schedule. With annotations present, this is adequate but not rich.

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

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

The description is a single, concise sentence with no wasted words. It front-loads the action and resource, and the parenthetical adds necessary clarification without becoming verbose. Every word contributes to understanding the tool's purpose.

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

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

The tool is simple, has one well-documented parameter, and benefits from strong annotations (readOnly, idempotent, openWorld). The description conveys the core returned concept—recurring slots for each day—but it does not explain the exact output structure or edge cases like how overrides are reflected. This is slightly incomplete, but for selecting and invoking the tool it is sufficient.

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

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

Schema coverage is 100% and the only parameter, calendarId, is clearly described as 'The calendar ID.' The description does not add any additional meaning or usage detail for this parameter. Since the schema fully documents the parameter, the baseline 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 a specific verb and resource: 'Get the weekly availability schedule for a calendar.' The parenthetical '(recurring slots for each day of the week)' adds a precise scope and distinguishes it from sibling tools like get_calendar_availability, which likely covers one-off availability rather than recurring weekly slots.

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 explicit guidance on when to use this tool versus alternatives. It does not mention when weekly recurring availability is needed instead of one-off availability, nor does it reference sibling tools such as get_calendar_availability or get_calendar_overrides. Usage context must be inferred entirely from the tool name and the parenthetical.

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 tool's safety profile is known. The description adds context by specifying the confirmation mode and communication channel, but does not describe return format, error behavior, or any other behavioral traits beyond what annotations convey.

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

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

The description is a single sentence that is front-loaded with the action and resource, and contains no unnecessary words. It is appropriately sized for the tool's simplicity.

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 single-parameter read tool with strong annotations, the description adequately indicates the response content (confirmation mode and communication channel). It lacks explicit return format or error conditions, but the low complexity makes this 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?

Schema coverage is 100% with calendarId described as 'The calendar ID'. The description does not add any additional meaning to the parameter beyond what the schema already provides, so 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 uses the specific verb 'Get' with the resource 'confirmation settings' and further clarifies scope with 'for a calendar' and the specific fields returned. It clearly distinguishes from the sibling tool 'update_confirmation_settings' and other get_* tools by naming the exact object.

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_calendar' or 'update_confirmation_settings'. The intended usage is only implied by the tool name and description, not explicitly stated.

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

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

Annotations already declare readOnlyHint=true, idempotentHint=true, and destructiveHint=false, covering the safety profile. The description adds little beyond 'detailed information,' but it does not contradict annotations and no further behavioral context is necessary for a simple getter.

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

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

The description is a single concise sentence that is front-loaded with the action and resource. Every word earns its place; there is no fluff or redundant information.

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

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

For a simple get-by-ID tool with one parameter and no output schema, the description is mostly sufficient, but 'detailed information' is vague and does not specify what fields will be returned. It lacks a bit of completeness but is not severely lacking.

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

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

Schema description coverage is 100% for the single parameter contactId, which is self-explanatory. The description does not add additional meaning beyond what the schema already provides, so the baseline of 3 is appropriate.

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

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

The description clearly states the action ('Get detailed information') and the resource ('a specific contact'), which distinguishes it from the sibling tool 'get_contacts' that lists contacts. The word 'specific' implies retrieval by ID, matching the contactId parameter.

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

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

The usage context is implied: use when you have a specific contact ID to retrieve details. However, the description does not explicitly mention when not to use it or contrast it with get_contacts, so guidance is minimal.

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 this as read-only, idempotent, and non-destructive, covering the safety profile. The description adds 'optional search' but this is also present in the input schema. No additional behavioral context (e.g., return format, pagination) is provided, but the annotations alleviate the need for safety 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, concise sentence that immediately conveys the action and optional search. There is zero waste, and the most important information 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?

For a simple list tool with two optional parameters and no output schema, the description is adequate. It does not explicitly state that it returns all contacts when no search is supplied, which is a minor gap, but overall it provides enough context for an agent to invoke the tool correctly.

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

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

Schema description coverage is 100% with clear descriptions for both 'limit' and 'search'. The tool description does not add any meaning beyond the schema, but per the rubric, a high coverage baseline yields a score 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 'List contacts with optional search' uses a specific verb (list) and resource (contacts), clearly distinguishing it from sibling tools like get_contact (singular) and create/update/delete_contact. It also hints at the optional search functionality, making the tool's purpose unambiguous.

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

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

The description implies usage for listing contacts, but does not explicitly state when to prefer this over get_contact or when not to use it. There is no mention of alternatives or exclusions, so usage guidance is only implied by the plural 'contacts' versus the singular sibling.

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?

Despite strong annotations (readOnlyHint, openWorldHint, idempotentHint), the description adds useful context by specifying 'recent' and 'in-app', which are not captured in the annotations. It does not disclose return format or pagination, but for a simple read operation this is acceptable.

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: 'Get recent in-app notifications.' It front-loads the action and resource with no unnecessary words.

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

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

Given the tool's simplicity (one optional parameter, strong annotations, no output schema), the description adequately conveys the main purpose. It could clarify what 'recent' means or describe the return structure, but the tool is straightforward enough that this is not a critical gap.

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

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

The input schema has 100% coverage for the single 'limit' parameter, with a clear description. The tool description adds no additional parameter semantics, so it meets 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 uses a specific verb 'Get' and clearly identifies the resource as 'recent in-app notifications'. This distinguishes it from sibling tools, which are all calendar/contact related, making the purpose unambiguous.

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

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

The description implies when to use the tool: to fetch recent in-app notifications. Since there are no other notification tools among siblings, explicit alternatives are not needed, but the description does not state any exclusions or prerequisites.

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

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

The description adds meaningful behavioral context: it says 'initiate a reschedule request,' implying this may not directly change the appointment but starts a request process. It also notes the write scope requirement. These go beyond the annotations (which already indicate a write operation) without contradicting them.

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

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

The description is two sentences, front-loaded with the action, and contains no fluff. Every word contributes to understanding the tool's purpose.

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

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

Given the lack of an output schema and the tool's simple nature, the description is adequate but leaves gaps. It doesn't explain what a 'reschedule request' entails (e.g., async behavior, what happens after) or what the response will look like. Still, the annotations cover safety profiles, so it's 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?

The input schema already provides descriptions for all three parameters with 100% coverage. The description adds no additional parameter-level detail, so the baseline score of 3 is appropriate.

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

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

The description clearly states the action: 'Initiate a reschedule request for an appointment.' The verb 'initiate' and resource 'reschedule request' are specific, and the tool is easily distinguished from siblings like cancel_appointment and get_appointment.

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

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

No guidance is given on when to use this tool versus alternatives like cancel_appointment or update_booking_settings. The only additional context is 'Requires write scope,' which is a prerequisite, not a usage guideline.

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 a write operation (readOnly=false) and non-idempotent, non-destructive properties. The description adds valuable side-effect information by stating the visitor will receive a confirmation request and that the invitation is sent on behalf of the provider, going beyond the structured 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 three sentences with no filler. It front-loads the main action, then adds the side effect and usage prerequisite, earning every word.

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 10-parameter write tool with no output schema, the description provides essential context: purpose, side effect, prerequisite (availability check), and contact identification modes. It does not explain return values or error cases, but this is minimally sufficient given the schema and 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 coverage is 100% with all parameters described. The description reiterates the contactId vs direct-fields relationship, which is already in the schema, and adds no new parameter-specific details. Therefore, it stays at the baseline for a fully documented 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 a specific action: sending an appointment invitation to a client on behalf of the service provider. This distinguishes it from sibling tools like cancel_appointment and reschedule_appointment by naming the unique operation and the recipient.

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?

It explicitly instructs to check availability first using get_calendar_availability, providing a clear precondition. It also explains the two contact-identification modes (contactId vs direct fields), giving practical usage context for when to use this tool.

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

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

Annotations already indicate this is a write operation (readOnlyHint=false) and not destructive. The description adds no further behavioral context, such as whether the update is partial or full replacement, how unspecified fields are handled, or any side effects. It merely restates the tool's purpose, offering minimal transparency beyond 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 front-loads the verb and object. Every word earns its place, with no redundancy or filler.

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

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

For a mutation tool with 6 parameters and no output schema, this description is too sparse. It fails to clarify whether the update is partial or full replacement, what happens to unspecified constraints, or what the tool returns. This leaves important ambiguity for an agent deciding how to invoke it correctly.

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

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

Schema description coverage is 100%, so all parameters are fully documented. The description's mention of 'min notice, max advance, buffers' maps directly to schema properties but adds no detail beyond what the schema already provides. 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 function: 'Update booking constraints for a calendar' and gives specific examples (min notice, max advance, buffers). This distinguishes it from sibling tools like update_calendar or update_confirmation_settings, which focus on other aspects.

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 the tool is for adjusting booking policies, but it provides no explicit when/when-not guidance or references to alternatives. The distinction from update_calendar and update_confirmation_settings is not articulated, 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?

Annotations already indicate a write operation (readOnlyHint=false) and open-world behavior. The description adds only the list of field examples but does not clarify whether updates are partial or full, or any side effects. It doesn't contradict annotations, but adds minimal behavioral detail.

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

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

One sentence, front-loaded, no fluff. It efficiently states the purpose.

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

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

Despite a detailed schema, the description is sparse for a tool with 14 parameters. It lacks guidance on partial vs full update behavior, conditional dependencies between parameters (e.g., conflictCalendarIds with conflictMode), and return value expectations. This could lead to incorrect invocation.

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

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

Schema has 100% coverage for 14 parameters, so the baseline is 3. The description mentions several fields but doesn't add any semantic information beyond what the schema descriptions already provide.

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

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

The description clearly identifies the action ('Update') and the resource ('calendar settings'), listing representative fields. It distinguishes from siblings like create_calendar and delete_calendar, though it doesn't explicitly separate from other update_* tools.

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

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

No explicit guidance on when to use this tool versus update_booking_settings or update_calendar_weekly_availability. The context is somewhat implied by the name, but there are no exclusions or alternative recommendations.

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

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

The description states 'This replaces all existing slots,' which is a destructive behavior, but the annotation destructiveHint=false. This directly contradicts the annotation. Therefore, despite the useful disclosure, the contradiction forces a score of 1.

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

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

Two short sentences, with the key replacement behavior disclosed in the second sentence. The description is front-loaded and contains no 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 simple two-parameter tool with full schema coverage, the description covers the essential purpose and the critical replacement behavior. However, it does not address openWorldHint implications or provide usage context, and the contradiction with destructiveHint is a notable gap.

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

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

The input schema provides 100% coverage for both parameters (calendarId and slots), including detailed descriptions for the slot object fields. The description adds no additional parameter semantics beyond what the schema already documents, so the baseline 3 applies.

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

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

The description clearly states the tool updates the weekly availability schedule for a calendar, with a specific verb and resource. It also explicitly notes that it replaces all existing slots, distinguishing it from read-only siblings like get_calendar_weekly_availability.

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

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

The description implies usage for updating weekly availability, but provides no explicit when-to-use guidance or alternatives. It does not contrast with related tools like update_calendar or create_calendar_override.

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=false and destructiveHint=false, so the description doesn't need to repeat that. The description adds the scope of the update (manual/auto-verify, email/SMS) but doesn't disclose whether it's a partial or full update, or any permission requirements. Since annotations cover the basic operational traits, a score of 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, front-loaded sentence that communicates the tool's purpose and key options without any waste. It earns its place and is 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?

The tool is simple with full schema coverage and annotations providing operational context. The description adequately covers the purpose and main parameters. However, it doesn't specify whether updating one setting preserves or resets others (partial vs full update), which is a minor gap for a mutation tool. Given the low complexity, this is sufficient.

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

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

Schema coverage is 100%, and the schema already describes each parameter and enum value in detail. The description merely mentions the enum values ('manual vs auto-verify, email vs SMS') without adding new information, so it adds no value 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 tool updates confirmation settings for a calendar, with specific verb 'Update' and resource 'confirmation settings'. It distinguishes from siblings like get_confirmation_settings (read) and update_booking_settings (different settings).

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 makes it obvious when to use the tool (to update confirmation settings), and sibling tools like get_confirmation_settings indicate an alternative for reading. However, no explicit when-not-to-use or alternative tool names are given, so it doesn't quite reach 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?

Annotations already indicate readOnlyHint=false and destructiveHint=false, so the write nature is known. The description adds the write scope requirement, which is useful context beyond annotations. However, it does not disclose whether the update is partial (only provided fields) or full replacement, nor what happens if the contact does not exist. With annotations lowering the bar, 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 sentence that efficiently communicates purpose and a prerequisite (write scope). No unnecessary words or repetition, making it appropriately sized and 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?

For a simple update tool with six basic parameters and existing annotations, the description covers the purpose and permission. However, it lacks crucial behavioral details like whether the update is partial (patch) or full (put), and what the response contains. The absence of an output schema and the openWorldHint also leave room for ambiguity, making this minimally viable but not complete.

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

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

The schema covers all six parameters with individual descriptions (100% coverage). The description adds no parameter-specific meaning beyond what the schema already provides, so the baseline of 3 is correct.

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 function ('Update an existing contact') with a specific verb and resource. It distinguishes from sibling tools like create_contact and delete_contact by explicitly indicating modification of an existing 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 for modifying an existing contact and notes the write scope requirement, but it does not explicitly state when to prefer this over alternatives (e.g., create_contact for new contacts) or provide exclusion criteria. The context is clear but lacks explicit guidance.

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