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

Annotations indicate this is a write operation (readOnlyHint: false) with open-world behavior (openWorldHint: true), non-idempotent, and non-destructive. The description adds value by specifying the return format ('newly created person record with its assigned ID') and error behavior ('Returns "Error: ..." if validation fails'), which are not covered by annotations. No contradiction with annotations exists.

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

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

The description is structured with a clear purpose statement, parameter list, and return/error information. It is front-loaded and efficiently organized, though the parameter section could be more concise given the schema already covers these details. Every sentence adds value, but there is minor redundancy.

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

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

Given the tool's complexity (8 parameters, write operation) and lack of output schema, the description provides sufficient context: it explains the action, parameters, return value, and error handling. However, it could improve by addressing potential side effects or integration with sibling tools, making it nearly complete but with minor gaps.

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

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

Schema description coverage is 100%, with each parameter well-documented in the schema (e.g., formats, enums, defaults). The description repeats some parameter details (e.g., birthdate format, gender options, status default) but adds minimal extra semantic context beyond what the schema already provides, aligning with the baseline for high coverage.

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

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

The description clearly states the specific action ('Create a new person record') and target resource ('in Planning Center People'), using a distinct verb that differentiates it from sibling tools like pco_get_person, pco_list_people, and pco_update_person. It precisely communicates the tool's function without ambiguity.

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 through its title and parameter details but does not explicitly state when to use this tool versus alternatives like pco_update_person or pco_list_people. It provides basic context (creating a new record) but lacks explicit guidance on prerequisites, exclusions, or comparisons with sibling tools.

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

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

Annotations already provide readOnlyHint, openWorldHint, idempotentHint, and destructiveHint, covering safety and idempotency. The description adds valuable context beyond annotations by specifying the return content (full event record with specific fields) and error behavior ('Error: Resource not found' for invalid IDs), which helps the agent understand outcomes.

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 well-structured and front-loaded with the main purpose, followed by specific sections for arguments, returns, and errors. Every sentence adds necessary information without redundancy, 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?

Given the tool's low complexity (2 parameters, no nested objects) and rich annotations, the description is mostly complete. It covers purpose, parameters, returns, and errors. However, without an output schema, it could benefit from more detail on the return structure, though the listed fields provide adequate guidance for an agent.

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

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

Schema description coverage is 100%, with clear descriptions for both parameters in the input schema. The description adds minimal value beyond the schema by listing the parameters and their purposes in the 'Args' section, but it does not provide additional syntax or format details. This meets the baseline for high schema coverage.

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

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

The description clearly states the tool's purpose with a specific verb ('Get detailed information') and resource ('about a specific calendar event'). It distinguishes from sibling tools like 'pco_list_calendar_events' by specifying retrieval of a single event rather than listing multiple events.

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

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

The description implies usage context by mentioning 'specific calendar event' and the error case for invalid IDs, but it does not explicitly state when to use this tool versus alternatives like 'pco_list_calendar_events' or provide guidance on prerequisites. This leaves some ambiguity for the agent.

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 valuable behavioral context beyond what annotations provide. While annotations already indicate this is a safe, read-only, idempotent operation (readOnlyHint: true, destructiveHint: false, idempotentHint: true), the description discloses the error behavior ('Returns "Error: Resource not found" if the ID is invalid') and output format options. This enhances the agent's understanding of how the tool behaves in practice.

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 structured and concise. It begins with the core purpose, then clearly sections parameter information and return/error details. Every sentence earns its place, with no wasted words or redundant information. The formatting with clear sections (Args, Returns, Error) enhances 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 simple read operation with comprehensive annotations and full schema coverage, this description provides complete contextual information. It covers purpose, parameters, return values, and error handling. The absence of an output schema is compensated by the clear description of what's returned ('Full donation record including amount, payment details, fund designations, and dates').

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

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

With 100% schema description coverage, the input schema already fully documents both parameters (id and response_format). The description mentions the parameters but doesn't add meaningful semantic context beyond what's in the schema descriptions. The baseline score of 3 is appropriate when the schema does the heavy lifting for parameter documentation.

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

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

The description clearly states the tool's purpose with a specific verb ('Get detailed information') and resource ('about a specific donation by ID'), distinguishing it from sibling tools like pco_list_donations (which lists multiple donations) and other get_* tools that target different resources. The description explicitly identifies the target resource and operation.

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: when you need detailed information about a specific donation identified by ID. It doesn't explicitly mention when NOT to use it or name alternatives like pco_list_donations, but the specificity of 'by ID' strongly implies this is for single-record retrieval rather than listing 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 cover key traits (read-only, non-destructive, idempotent, open-world). The description adds useful context about error handling ('Error: Resource not found' for invalid ID) and return content details, but doesn't mention rate limits, auth needs, or other behavioral aspects 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 well-structured and front-loaded with the core purpose, followed by Args and Returns sections. Every sentence adds value: the first states the action, Args clarifies parameters, Returns details output, and Error handles edge cases—zero waste.

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

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

Given the tool's simplicity (2 parameters, no output schema, rich annotations), the description is mostly complete. It covers purpose, parameters, returns, and errors, but could benefit from more behavioral context (e.g., rate limits) since annotations don't cover everything.

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

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

Schema description coverage is 100%, so parameters are fully documented in the schema. The description adds minimal value beyond schema by listing 'id' and 'response_format' in the Args section, but doesn't provide additional semantics like format examples or usage tips.

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 ('detailed information about a specific group'), specifying it's by ID. It distinguishes from sibling tools like 'pco_list_groups' (which lists multiple groups) by focusing on a single group retrieval.

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 detailed info for a specific group ID, but doesn't explicitly state when NOT to use it or compare to alternatives like 'pco_list_groups' for broader queries. It provides clear context but lacks explicit 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?

Annotations already declare this as read-only, non-destructive, idempotent, and open-world. The description adds valuable behavioral context beyond annotations: it specifies the return format options (markdown/json), describes the error behavior ('Error: Resource not found' for invalid ID), and indicates what data is included ('Full person record including all attributes'). This provides practical usage information not captured in 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 well-structured with clear sections (purpose, args, returns, error) and appropriately sized. The first sentence immediately states the core purpose. However, the 'Args' section could be more concise since it largely duplicates schema information that's already available to the agent.

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 operation with comprehensive annotations (readOnlyHint, openWorldHint, idempotentHint, destructiveHint), the description provides complete context. It covers purpose, parameters, return format options, error handling, and data scope. With no output schema, the description appropriately explains what's returned ('Full person record including all attributes').

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

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

With 100% schema description coverage, the schema already fully documents both parameters. The description's 'Args' section essentially repeats the schema information without adding significant semantic context beyond what's already in the schema descriptions. The baseline of 3 is appropriate when the schema does the heavy lifting.

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

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

The description explicitly states 'Get detailed information about a single person by their PCO ID' - a specific verb ('Get') and resource ('person') with clear scope ('single person', 'detailed information'). It distinguishes from sibling tools like pco_list_people (which lists multiple people) and pco_update_person (which modifies rather than retrieves).

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 ('by their PCO ID' for a single person) but doesn't explicitly mention when NOT to use it or name specific alternatives. The sibling tools list shows pco_list_people as an obvious alternative for listing multiple people, but this isn't called out in the description itself.

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, destructiveHint=false, openWorldHint=true, and idempotentHint=true, covering safety and idempotency. The description adds useful context about error handling ('Returns "Error: Resource not found" if IDs are invalid') and output format behavior, but doesn't provide additional behavioral details like rate limits, authentication requirements, or pagination.

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 well-structured with clear sections (purpose, Args, Returns, Error) and uses efficient language. However, the Args section somewhat duplicates schema information, and the description could be slightly more concise by integrating the format default information more seamlessly.

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

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

Given the tool's moderate complexity (3 parameters, no output schema), the description provides good coverage: purpose, parameters, return details, and error handling. With comprehensive annotations covering safety and idempotency, and 100% schema coverage, the description is mostly complete but could benefit from more explicit sibling differentiation.

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

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

With 100% schema description coverage, the schema already documents all parameters thoroughly. The description adds minimal value beyond the schema, mentioning the parameters in the Args section but not providing additional semantic context. The baseline score of 3 is appropriate when the schema does the heavy lifting.

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

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

The description clearly states the tool's purpose with specific verb ('Get detailed information') and resource ('about a specific plan in Planning Center Services'), distinguishing it from sibling tools like pco_list_plans (which lists multiple plans) and other get_* tools that retrieve different resource types.

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

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

The description implies usage context by specifying it retrieves 'detailed information about a specific plan' and mentions error conditions for invalid IDs, providing clear operational context. However, it doesn't explicitly state when to use this vs. alternatives like pco_list_plans or other get_* tools for different resources.

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

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

Annotations already indicate read-only, open-world, idempotent, and non-destructive behavior. The description adds valuable context beyond this by specifying the return format options ('markdown' or 'json'), default values, and error handling ('Returns "Error: ..." if the request fails'), which are not covered by annotations. No contradictions with annotations exist.

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 well-structured and front-loaded with the core purpose, followed by a clear 'Args' section and return/error information. Every sentence earns its place by providing essential details without redundancy, 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?

Given the tool's complexity (list operation with filtering and pagination), annotations cover safety aspects, and the description adds output format and error handling. However, there is no output schema, and the description does not fully explain the structure of returned events (e.g., fields like 'name', 'approval status' are mentioned but not detailed), leaving some gaps in completeness.

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

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

Schema description coverage is 100%, meaning the input schema already fully documents all parameters. The description repeats some parameter details (e.g., filter options, limit range, default values) but does not add significant meaning beyond what the schema provides, such as explaining why certain filters exist or how pagination works in practice. Baseline 3 is appropriate given high schema coverage.

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

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

The description clearly states the verb ('List') and resource ('events in Planning Center Calendar'), making the purpose specific. It distinguishes itself from siblings like 'pco_get_calendar_event' (singular retrieval) and 'pco_list_calendar_resources' (different resource type), avoiding tautology by not just repeating the name/title.

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

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

The description provides clear context for usage through the 'filter' parameter options (e.g., 'approved', 'future'), which implicitly guides when to apply specific filters. However, it does not explicitly state when to use this tool versus alternatives like 'pco_list_event_instances' or 'pco_list_checkin_events', 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?

Annotations already cover key behavioral traits (read-only, open-world, idempotent, non-destructive), so the description adds value by specifying the return format options ('markdown' or 'json') and error handling ('Error: ...' if the request fails). It doesn't contradict annotations and provides useful context beyond them, though it lacks details on rate limits or authentication needs.

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 efficiently structured with a clear purpose statement followed by 'Args:' and 'Returns:' sections, all in a compact format. Every sentence earns its place by providing essential information without redundancy, making it easy to scan and understand quickly.

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

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

Given the tool's low complexity (simple list operation), rich annotations (covering safety and behavior), and full parameter documentation in the schema, the description is largely complete. It explains the output format and error handling, though without an output schema, it could benefit from more detail on the return structure (e.g., pagination or field examples).

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

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

With 100% schema description coverage, the input schema fully documents all parameters (limit, offset, response_format), including their types, ranges, defaults, and purposes. The description adds no additional semantic meaning beyond what's in the schema, so it meets the baseline of 3 without compensating for any gaps.

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

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

The description clearly states the verb ('List') and resource ('facility resources (rooms, equipment) in Planning Center Calendar'), making the purpose specific and unambiguous. It distinguishes itself from sibling tools like 'pco_list_calendar_events' by focusing on resources rather than events, ensuring no confusion with similar list operations.

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

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

The description implies usage for retrieving resource lists but provides no explicit guidance on when to use this tool versus alternatives. While the context of 'facility resources' suggests it's for rooms/equipment, there's no mention of prerequisites, exclusions, or comparisons to other list tools (e.g., 'pco_list_groups'), leaving the agent to infer usage from the purpose 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 provide comprehensive behavioral hints (readOnlyHint: true, openWorldHint: true, idempotentHint: true, destructiveHint: false). The description adds minimal value beyond this by specifying the return format options and error behavior, but doesn't disclose important operational details like rate limits, authentication requirements, or what 'enable settings' specifically means.

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 well-structured with clear sections for purpose, arguments, returns, and errors. It's appropriately sized for the tool's complexity, though the 'Args' section could be more concise since it largely duplicates schema information.

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

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

Given the rich annotations (covering safety and idempotency) and complete parameter documentation in the schema, the description provides adequate context for a listing operation. However, without an output schema, the description should more clearly explain the structure of returned events (beyond just 'name, frequency, and enable settings') and what 'enable settings' specifically entails.

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

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

With 100% schema description coverage, the input schema already fully documents all three parameters with their constraints, defaults, and purposes. The description's 'Args' section essentially repeats what's in the schema without adding meaningful semantic context beyond what's already structured.

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

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

The description clearly states the verb ('List') and resource ('events (attendance tracking sessions) in Planning Center Check-Ins'), providing specific functionality. However, it doesn't explicitly differentiate from sibling tools like 'pco_list_checkins' or 'pco_list_event_instances', which might have overlapping domains in the same system.

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

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

The description provides no guidance on when to use this tool versus alternatives. With multiple sibling list tools in the Planning Center ecosystem (e.g., pco_list_checkins, pco_list_event_instances), there's no indication of what makes this tool distinct or when it should be preferred over other listing tools.

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

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

Annotations already declare readOnlyHint=true, destructiveHint=false, openWorldHint=true, and idempotentHint=true, covering safety and idempotency. The description adds useful behavioral context beyond annotations: it specifies the return format options (markdown/json), describes error behavior ('Error: Resource not found'), and mentions pagination through limit/offset parameters. However, it doesn't detail rate limits or authentication 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 well-structured with a clear purpose statement followed by Args and Returns sections. It's appropriately sized at 5 sentences, though the parameter details in the Args section largely duplicate schema information, making it slightly less efficient than it could be.

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

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

Given the tool's moderate complexity (4 parameters, pagination, format options) and rich annotations covering safety aspects, the description is mostly complete. It explains what the tool returns and error conditions, though without an output schema, it could benefit from more detail about the structure of returned location objects beyond 'name, capacity, and check-in count.'

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

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

Schema description coverage is 100%, so the schema already fully documents all parameters. The description repeats parameter information (event_id source, limit range, offset purpose, response_format options) but doesn't add significant meaning beyond what's in the schema. This meets the baseline for high schema coverage.

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

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

The description clearly states the specific action ('List locations (rooms) for a check-in event') and resource ('Planning Center Check-Ins'), distinguishing it from sibling tools like pco_list_checkin_events (which lists events rather than locations). The verb 'List' is precise and matches the tool's read-only nature.

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 specifying it's for 'a check-in event' and mentions getting the event_id from pco_list_checkin_events, which helps guide usage. However, it doesn't explicitly state when NOT to use this tool or name direct alternatives among siblings, keeping it from 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?

The description adds valuable behavioral context beyond what annotations provide. While annotations already indicate this is a read-only, non-destructive, idempotent operation with open-world data, the description specifies the return format options ('markdown' | 'json'), error handling behavior ('Returns "Error: ..." if the request fails'), and the specific fields included in results ('name, security code, kind, and timestamps'). This enhances the agent's understanding of how to interpret outputs.

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 well-structured with clear sections for Args, Returns, and Error handling. It's appropriately sized for a tool with 5 parameters and no output schema. While efficient, the repetition of parameter information that's already in the schema could be considered slightly redundant, preventing a perfect score.

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

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

Given the tool's moderate complexity (5 parameters, no output schema) and rich annotations, the description provides good contextual completeness. It covers purpose, parameters, return format options, error handling, and result fields. The main gap is the lack of explicit usage guidelines compared to sibling tools, but overall it gives the agent sufficient information to use the tool effectively.

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

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

With 100% schema description coverage, the schema already fully documents all 5 parameters. The description repeats the parameter information in the 'Args' section but doesn't add significant semantic value beyond what's in the schema. The baseline score of 3 is appropriate since the schema does the heavy lifting, though the description provides a convenient summary.

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

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

The description clearly states the verb ('List') and resource ('check-in records in Planning Center Check-Ins'), making the purpose specific and unambiguous. It distinguishes itself from siblings like 'pco_list_checkin_events' and 'pco_list_checkin_locations' by focusing specifically on check-in records rather than events or locations.

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 through the parameter descriptions (date filtering, pagination, output format), but doesn't explicitly state when to use this tool versus alternatives. No guidance is provided about when not to use it or which sibling tools might be better for related tasks like listing check-in events or locations.

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 cover key behavioral traits (read-only, non-destructive, idempotent, open-world), so the description adds minimal value by specifying the return format and error handling. It does not disclose additional context like rate limits, authentication needs, or pagination details beyond what annotations imply, but it does not contradict them either.

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

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

The description is appropriately sized and front-loaded, starting with the core purpose followed by parameter and return details in a structured format. However, the 'Args' and 'Returns' sections are somewhat redundant with the schema, slightly reducing efficiency, but overall it avoids unnecessary verbosity.

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

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

Given the tool's low complexity (list operation), rich annotations, and full schema coverage, the description is mostly complete. It lacks output schema but describes return values and errors adequately. Minor gaps include no mention of sorting, filtering options, or sibling tool differentiation, but it suffices for basic use.

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

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

Schema description coverage is 100%, with all parameters well-documented in the input schema. The description repeats parameter details without adding significant meaning beyond the schema, such as explaining why 'response_format' matters or how 'offset' interacts with pagination. This meets the baseline for high schema coverage.

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

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

The description clearly states the verb ('List') and resource ('donation batches in Planning Center Giving'), making the purpose specific and unambiguous. However, it does not explicitly differentiate from sibling tools like 'pco_list_donations', which might cause confusion about scope, preventing a perfect score.

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

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

The description provides no guidance on when to use this tool versus alternatives, such as 'pco_list_donations' or other list tools. It lacks context about prerequisites, timing, or exclusions, offering only basic functional information without usage scenarios.

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

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

Annotations already provide readOnlyHint=true, openWorldHint=true, idempotentHint=true, and destructiveHint=false. The description adds valuable context beyond this: it specifies the return format options ('markdown' or 'json'), describes the return content ('List of donations with amount, payment method, date, and status'), and mentions error behavior ('Returns "Error: ..." if the request fails'). This significantly enhances behavioral understanding beyond 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 reasonably structured with purpose statement, parameter documentation, and return information. However, the 'Args' section is somewhat redundant given the comprehensive schema, and the overall description could be more front-loaded with critical information. It's adequately concise but not optimally 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?

For a read-only listing tool with comprehensive annotations and 100% schema coverage, the description provides good additional context: it specifies return format options, describes the return content, and mentions error handling. The main gap is lack of guidance on when to use this versus sibling tools, but overall it's reasonably complete for this type of operation.

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

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

Schema description coverage is 100%, so the schema already fully documents all 7 parameters. The description's 'Args' section essentially repeats what's in the schema without adding meaningful additional context about parameter interactions, constraints, or usage patterns. This meets the baseline expectation when schema coverage is complete.

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 'List donations in Planning Center Giving' which is a specific verb+resource combination. However, it doesn't explicitly differentiate from sibling tools like 'pco_get_donation' or 'pco_list_donation_batches', which would require more specific scope information to earn a 5.

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

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

The description provides no guidance on when to use this tool versus alternatives like 'pco_get_donation' (for single donation) or 'pco_list_donation_batches'. There's no mention of prerequisites, typical use cases, or comparison with sibling tools, leaving the agent without contextual usage direction.

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

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

Annotations already provide readOnlyHint=true, destructiveHint=false, openWorldHint=true, and idempotentHint=true, covering safety and idempotency. The description adds value by disclosing the error behavior ('Error: Resource not found' for invalid event ID) and the return content (list with start/end times and location), which are not covered by annotations. However, it lacks details on rate limits or authentication needs, so it adds some but not extensive 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 front-loaded with the core purpose in the first sentence, followed by a structured 'Args:' and 'Returns:' section that efficiently covers key details without waste. Every sentence serves a clear purpose, making it easy to scan and understand.

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

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

Given the tool's complexity (a read-only list operation with pagination and format options), annotations cover safety, and the description adds error handling and return content. However, there is no output schema, so the description partially compensates by specifying return values. It could be more complete by detailing pagination behavior or example outputs, but it is largely adequate for the 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%, meaning all parameters are well-documented in the schema. The description adds minimal value beyond the schema by restating parameter purposes (e.g., 'event_id' as calendar event ID) and default values, but does not provide additional syntax or format details. This meets the baseline for high schema coverage.

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

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

The description clearly states the verb 'List' and the resource 'specific instances (occurrences) of a calendar event', which is specific and distinguishes it from sibling tools like pco_list_calendar_events (which lists events rather than their instances). This precise wording helps the agent understand the exact scope of the tool.

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

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

The description provides clear context by specifying that event_id should be obtained from pco_list_calendar_events, which implicitly guides usage. However, it does not explicitly state when to use this tool versus alternatives like pco_get_calendar_event or when not to use it, leaving some room for improvement in 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?

Annotations already declare readOnlyHint=true, openWorldHint=true, idempotentHint=true, and destructiveHint=false, covering safety and idempotency. The description adds value by specifying the return format options (markdown/json) and error behavior ('Returns "Error: ..." if the request fails'), which are not covered by annotations. No contradiction with annotations exists.

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

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

The description is well-structured with clear sections (Args, Returns, Error) and uses bullet points for readability. It is appropriately sized, but includes some redundancy with the schema (e.g., repeating parameter defaults). Every sentence serves a purpose, though minor trimming could improve efficiency.

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

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

Given the annotations cover safety and idempotency, and the description adds return format and error details, the tool is well-documented for a read-only listing operation. However, without an output schema, the description could better explain the structure of returned fund objects (e.g., field descriptions), though it lists key attributes like name and ledger code.

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 fully documented in the input schema. The description repeats parameter details (limit, offset, response_format) without adding meaningful semantics beyond what the schema provides, such as explaining pagination strategies or format use cases. This meets the baseline for high schema coverage.

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

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

The description clearly states the verb ('List') and resource ('giving funds in Planning Center Giving'), making the purpose specific and unambiguous. It distinguishes itself from siblings like pco_list_donations or pco_list_people by focusing on funds, which is a distinct resource type in the system.

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

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

The description implies usage context through the resource name ('giving funds'), but provides no explicit guidance on when to use this tool versus alternatives. There are no statements about prerequisites, when-not scenarios, or comparisons to sibling tools, leaving usage decisions to inference.

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, destructiveHint=false, openWorldHint=true, and idempotentHint=true, covering the safety profile. The description adds valuable behavioral context beyond annotations by specifying the return format options (markdown/json), pagination behavior (limit/offset), error handling ('Error: Resource not found'), and what data is returned (name, role, join date). This significantly enhances transparency.

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

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

The description is well-structured with a clear purpose statement followed by Args and Returns sections. It's appropriately sized with no wasted sentences, though the parameter details in the description somewhat duplicate schema information. The front-loaded purpose statement is effective, but some redundancy slightly reduces efficiency.

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 (5 parameters, 1 required), rich annotations (4 hints), and 100% schema coverage, the description is complete enough. It explains what the tool does, provides usage guidance, describes return values and error handling, and complements the structured data well. No output schema exists, so the description appropriately covers return information.

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

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

Schema description coverage is 100%, so the schema already fully documents all 5 parameters with descriptions, enums, defaults, and constraints. The description repeats some of this information (e.g., filter options, limit range, default values) but doesn't add significant meaning beyond what's in the schema. The baseline of 3 is appropriate when the schema does the heavy lifting.

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

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

The description clearly states the specific action ('List members') and resource ('of a specific group in Planning Center Groups'), distinguishing it from sibling tools like pco_list_groups (which lists groups) and pco_list_people (which lists people generally). The verb+resource combination is precise and 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 provides clear context by specifying it's for 'a specific group' and mentions obtaining the group_id from pco_list_groups, which is helpful guidance. However, it doesn't explicitly state when to use this tool versus alternatives like pco_get_group (which might return group details including members) or when not to use it, leaving some room for improvement.

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 strong behavioral hints (readOnlyHint: true, destructiveHint: false, idempotentHint: true, openWorldHint: true). The description adds useful context about the return format options (markdown/json) and error handling ('Error: ...'), but doesn't mention rate limits, authentication needs, or what 'openWorldHint' means in this 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 well-structured with clear sections (Args, Returns, Error) and front-loads the core purpose. It's appropriately sized for a list operation with multiple parameters, though some parameter details could be trimmed since they're fully covered in the schema.

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

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

For a read-only list tool with comprehensive annotations and full schema coverage, the description provides adequate context. It explains the return format options and error handling, though without an output schema, it could benefit from more detail about the structure of returned group objects beyond the listed fields.

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

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

With 100% schema description coverage, the schema already fully documents all 5 parameters. The description repeats some parameter information (like search/filter purposes) but doesn't add significant meaning beyond what's in the schema. The baseline of 3 is appropriate when the schema does the heavy lifting.

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

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

The description clearly states the verb 'List' and resource 'groups in Planning Center Groups', making the purpose specific and unambiguous. It distinguishes this tool from siblings like 'pco_get_group' (singular retrieval) and 'pco_list_group_members' (different resource).

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

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

The description provides clear context for usage through the parameter explanations (searching, filtering, pagination, output format), which implicitly guides when to use this tool. However, it doesn't explicitly state when to choose this over alternatives like 'pco_get_group' or mention any prerequisites or exclusions.

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

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

The description adds some behavioral context beyond annotations: it specifies the return format ('List of group types with name and group count') and error handling ('Error: Returns "Error: ..." if the request fails'). However, annotations already provide comprehensive safety information (readOnlyHint, non-destructive, idempotent, openWorld), so the bar is lower. The description doesn't add information about rate limits, authentication needs, or other behavioral traits.

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 well-structured and appropriately sized. It starts with the core purpose, provides context about group types, then documents parameters and return values. The 'Args' and 'Returns' sections are clear. While efficient, the parameter documentation duplicates schema information, slightly reducing conciseness value.

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 (list operation with pagination), comprehensive annotations, and 100% schema coverage, the description is reasonably complete. It explains what's returned and error handling, though there's no output schema. The main gap is lack of usage guidance relative to sibling tools, but for a straightforward list tool, the description provides adequate 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?

The description includes an 'Args' section that documents all three parameters, but the input schema already has 100% description coverage with identical information. The description adds no additional semantic context beyond what's already in the schema properties. With complete schema coverage, the baseline is 3 even without extra parameter explanation 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 tool's purpose: 'List group types in Planning Center Groups' with a specific verb ('List') and resource ('group types'). It provides helpful context about what group types are ('categorize groups...'), but doesn't explicitly differentiate from sibling tools like 'pco_list_groups' or 'pco_list_service_types'.

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

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

The description provides no guidance on when to use this tool versus alternatives. While the title suggests it's for listing group types, there's no mention of when this would be appropriate versus listing groups themselves or other related resources. No exclusions, prerequisites, or alternative tools are mentioned.

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

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

Annotations cover key traits (read-only, non-destructive, idempotent, open-world), so the bar is lower. The description adds value by specifying the return format options and error behavior, but doesn't mention rate limits, authentication needs, or pagination details beyond what's in the schema.

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

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

The description is well-structured with a clear purpose statement, parameter details, and return/error info. It's slightly verbose in repeating schema details, but overall efficient and front-loaded with the core functionality.

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

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

For a read-only list tool with comprehensive annotations and schema, the description adequately covers purpose, parameters, returns, and errors. It lacks sibling differentiation and deeper behavioral context, but given the structured data richness, it's mostly complete.

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

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

Schema description coverage is 100%, providing detailed parameter documentation. The description repeats parameter info in the 'Args' section but doesn't add meaningful context beyond the schema, such as when to use pagination or format choices. Baseline 3 is appropriate given high schema coverage.

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

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

The description clearly states the verb ('List') and resource ('households in Planning Center People'), making the purpose unambiguous. However, it doesn't explicitly differentiate from sibling tools like 'pco_list_people' or 'pco_list_groups', which would require a 5.

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

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

The description provides no guidance on when to use this tool versus alternatives like 'pco_list_people' or 'pco_list_groups'. It lacks context about what constitutes a 'household' versus other entities, leaving the agent to infer usage scenarios.

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

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

Annotations already declare readOnlyHint=true, destructiveHint=false, openWorldHint=true, and idempotentHint=true, covering safety and idempotency. The description adds valuable behavioral context beyond annotations: it specifies the return format options (markdown/json), describes error behavior ('Returns "Error: ..." message if the request fails'), and mentions partial matching for name searches. However, it doesn't address rate limits, authentication requirements, or pagination details beyond offset/limit parameters.

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 well-structured with a clear purpose statement followed by parameter documentation and return information. It's appropriately sized for an 11-parameter tool. However, the Args section is somewhat redundant with the schema, and the front-loaded purpose statement could be slightly more specific about the tool's primary use cases beyond just 'search and list'.

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

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

Given the tool's complexity (11 parameters, no output schema), the description provides good context: it explains the tool's purpose, documents all parameters (though redundantly), describes return values and error behavior. With comprehensive annotations covering safety and idempotency, and 100% schema coverage, the description fills important gaps about return formats and error handling. It could benefit from more guidance on when to use specific filters or how results are ordered.

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

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

Schema description coverage is 100%, so the input schema already documents all parameters thoroughly with descriptions, constraints, and defaults. The description's Args section largely repeats what's in the schema (e.g., 'query (string, optional): Search by name (partial match on first or last name)' vs schema's 'Search by name (partial match)'). It adds minor clarification about partial matching applying to first or last name, but overall adds minimal value beyond the comprehensive 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 'Search for and list people in Planning Center People (PCO)' with specific verbs (search/list) and resource (people). It distinguishes from siblings like pco_get_person (singular retrieval) and pco_create_person (creation), but doesn't explicitly contrast with other list tools like pco_list_groups. The purpose is specific but sibling differentiation could be more explicit.

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 through the mention of filtering capabilities ('Supports filtering by name, status, and more'), suggesting when this tool would be appropriate. However, it doesn't provide explicit guidance on when to use this versus alternatives like pco_get_person for single-person retrieval or pco_list_people_lists for different data. No exclusions or prerequisites are mentioned.

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

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

Annotations already provide readOnlyHint=true, destructiveHint=false, openWorldHint=true, and idempotentHint=true, covering safety and idempotency. The description adds valuable context beyond annotations by specifying the return format options (markdown/json), error message format ('Error: ...'), and that it returns specific fields (name, description, status, total count).

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 efficiently structured with a clear purpose statement, parameter details in a bullet-like format, and return/error information. Every sentence adds value without redundancy, and it's appropriately sized for the tool's complexity.

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 rich annotations (readOnly, openWorld, idempotent, non-destructive), 100% schema coverage, and no output schema needed, the description provides complete context. It covers purpose, parameters, return format options, error handling, and specific return fields, making it fully adequate for agent use.

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

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

With 100% schema description coverage, the input schema already fully documents all three parameters. The description adds minimal value beyond the schema, only restating parameter names and default values without providing additional semantic context. This meets the baseline of 3 for high schema coverage.

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

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

The description clearly states the verb ('List') and resource ('smart lists (saved filters) in Planning Center People'), specifying that these are saved filters rather than raw people data. It distinguishes from sibling tools like 'pco_list_people' which lists actual people, not saved filter lists.

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

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

The description implies usage context by specifying it's for 'smart lists (saved filters)' in Planning Center People, which suggests when to use it versus raw people listing tools. However, it doesn't explicitly state when-not-to-use alternatives or prerequisites, keeping it at a 4 rather than a 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 cover read-only, open-world, idempotent, and non-destructive traits, but the description adds valuable context: it specifies the return format options (markdown/json), details the output content (list with location and primary status), and mentions error behavior ('Error: Resource not found' for invalid IDs). This enhances transparency beyond 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 well-structured and front-loaded with the core purpose, followed by clear sections for Args and Returns. Every sentence adds value without redundancy, making it efficient and easy for an agent to parse quickly.

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

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

Given the tool's low complexity (2 parameters, 100% schema coverage, rich annotations), the description is complete. It covers purpose, parameters, return values, and error handling, compensating for the lack of an output schema. No gaps are present for this straightforward read operation.

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

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

Schema description coverage is 100%, providing full parameter documentation. The description adds minimal extra semantics, such as clarifying that 'response_format' controls output format, but does not significantly expand on the schema's details. This 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 tool's purpose with a specific verb ('Get') and resource ('all email addresses for a specific person in PCO'), distinguishing it from siblings like 'pco_get_person' (which likely retrieves general person data) and 'pco_list_people' (which lists multiple people). It explicitly mentions the scope of returning email addresses with location and primary status.

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 email addresses for a specific person are needed, but it does not explicitly state when to use this tool versus alternatives like 'pco_get_person' (which may include email data) or 'pco_list_people' (for broader listings). No exclusions or prerequisites are mentioned, leaving some ambiguity for the agent.

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, destructiveHint=false, openWorldHint=true, and idempotentHint=true, covering safety and idempotency. The description adds useful context beyond annotations: it specifies the return format options (markdown/json), details the error response ('Error: Resource not found'), and lists what data is returned (carrier, location, primary status). However, it doesn't mention rate limits, authentication needs, or pagination behavior.

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

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

The description is well-structured and front-loaded, starting with the core purpose, followed by Args and Returns sections. Every sentence earns its place: the first sentence states the purpose, the Args clarify parameters, and the Returns/Error sections provide essential output details without redundancy.

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

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

Given the tool's low complexity (2 parameters, no nested objects), rich annotations (covering safety and idempotency), and no output schema, the description is mostly complete. It explains the purpose, parameters, return data, and error handling. However, it could improve by mentioning authentication requirements or rate limits, which are not covered by annotations.

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

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

Schema description coverage is 100%, with both parameters fully documented in the schema (person_id as 'The PCO person ID' and response_format with enum and default). The description adds minimal value beyond the schema, only restating the default for response_format and implying person_id is required. Baseline 3 is appropriate since the schema does the heavy lifting.

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

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

The description clearly states the verb ('Get all phone numbers') and resource ('for a specific person in PCO'), making the purpose specific. It distinguishes from sibling tools like pco_get_person (which retrieves general person data) and pco_list_people (which lists multiple people), focusing exclusively on phone numbers for a single person.

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 specifying it's for 'a specific person' and mentions error handling for invalid IDs, which helps guide usage. However, it doesn't explicitly state when to use this tool versus alternatives like pco_get_person (which might include phone numbers) or pco_list_person_emails, missing explicit 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?

Annotations already declare readOnlyHint=true, destructiveHint=false, openWorldHint=true, and idempotentHint=true. The description adds valuable behavioral context beyond annotations: it specifies the return format options (markdown/json), describes the return content (title, dates, people count, items count), and documents the specific error case for invalid service_type_id. This provides practical usage information that annotations don't cover.

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

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

The description is perfectly structured and front-loaded: the core purpose in the first sentence, followed by a clean Args section with bullet points, then Returns and Error sections. Every sentence earns its place with no wasted words. The formatting makes it easy to scan and understand quickly.

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

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

For a read-only listing tool with comprehensive annotations (readOnlyHint, openWorldHint, idempotentHint) and 100% schema coverage, the description provides excellent completeness. It covers purpose, parameters, return format options, return content, and error conditions. The lack of an output schema is compensated by the clear Returns description. No significant gaps remain for this type of tool.

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

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

With 100% schema description coverage, the schema already documents all parameters thoroughly. The description repeats some parameter information (filter options, limit range, default values) but doesn't add significant semantic meaning beyond what's in the schema. It does clarify that service_type_id comes from pco_list_service_types, which is helpful but minimal additional value.

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

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

The description clearly states the specific action ('List plans') with the resource ('for a specific service type in Planning Center Services'). It distinguishes from siblings like pco_get_plan (singular retrieval) and pco_list_service_types (different resource type). The verb+resource combination is precise and 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 provides clear context for when to use this tool (listing plans for a service type) and mentions where to get the required service_type_id (from pco_list_service_types). However, it doesn't explicitly state when NOT to use it or name specific alternatives among siblings, though the distinction from pco_get_plan is implied by the plural vs. singular naming.

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, non-destructive, idempotent, and open-world, covering key safety traits. The description adds valuable context beyond annotations: it specifies the return content ('title, artwork, and plan count'), error behavior ('Error: Resource not found'), and output format options, which helps the agent understand practical usage 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 efficiently structured: it starts with the core purpose, lists parameters with brief clarifications, and ends with return and error info. Every sentence serves a clear purpose, with no wasted words, 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 tool's moderate complexity (4 parameters, 1 required), rich annotations, and 100% schema coverage, the description is largely complete. It covers purpose, parameters, returns, and errors, though it lacks output schema details (e.g., structure of the list). The annotations handle behavioral aspects well, making this sufficient 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?

Schema description coverage is 100%, with each parameter well-documented in the schema itself. The description repeats some parameter info (e.g., 'response_format' options) but adds minimal extra meaning, such as noting 'service_type_id' comes from another tool. 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 verb ('List') and resource ('sermon/service series in Planning Center Services'), making the purpose immediately understandable. However, it doesn't explicitly differentiate this from sibling tools like 'pco_list_service_types' or 'pco_list_plans' that might also list related resources, 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 implied usage guidance by noting that 'service_type_id' should be obtained from 'pco_list_service_types', suggesting a workflow dependency. However, it lacks explicit when-to-use rules, alternatives, or exclusions compared to other list tools, leaving the agent to infer context from parameter requirements.

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 valuable behavioral context beyond annotations: it explains the return format options and error handling ('Returns: List of service types...', 'Error: Returns "Error: ..."'). While annotations already indicate this is a safe, read-only operation (readOnlyHint: true, destructiveHint: false), the description provides practical implementation details about output and error responses that aren't captured in 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 perfectly structured and concise: it begins with the core purpose, provides context about service types, then clearly documents parameters and return behavior in separate sections. Every sentence serves a distinct purpose with zero redundancy, making it easy to scan and understand.

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

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

For a read-only list tool with comprehensive annotations and full parameter documentation, the description provides excellent context. It explains what service types are, documents parameters and returns, and includes error handling. The only minor gap is the lack of output schema, but the description compensates by describing the return format. This is nearly complete for this tool type.

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

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

With 100% schema description coverage, the input schema already fully documents all three parameters. The description's 'Args' section essentially repeats what's in the schema without adding meaningful semantic context. However, it does provide the default values explicitly, which offers slight additional clarity beyond the schema's technical specifications.

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

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

The description clearly states the tool's purpose with a specific verb ('List') and resource ('service types'), and provides a helpful explanation of what service types represent ('different worship services'). It distinguishes this tool from siblings by focusing on a specific Planning Center Services resource, unlike tools for people, donations, or other entities.

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

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

The description implies usage context by mentioning 'Planning Center Services' and the nature of service types, but provides no explicit guidance on when to use this tool versus alternatives. There's no mention of prerequisites, related tools, or scenarios where this tool is preferred over other list tools in the sibling set.

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, destructiveHint=false, openWorldHint=true, and idempotentHint=true, covering safety and idempotency. The description adds valuable context beyond this: it specifies the return format options (markdown/json), describes what fields are included in results (title, author, CCLI number, last scheduled date), and mentions error behavior ('Error: ...' if request fails). This enhances understanding of the tool's behavior 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 well-structured with a clear purpose statement followed by parameter details and return information. It's appropriately sized for a 5-parameter tool with no output schema. However, the 'Args:' and 'Returns:' sections could be integrated more seamlessly, and some redundancy with the schema exists (e.g., repeating parameter descriptions).

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 (5 parameters, no output schema, rich annotations), the description is mostly complete. It covers purpose, parameters, return values, and error handling. The main gap is the lack of usage guidelines, but annotations handle safety aspects well, and the parameter details are thorough. For a list operation, this is sufficient but not exemplary.

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

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

Schema description coverage is 100%, with each parameter well-documented in the schema (e.g., 'Search songs by title' for query, range limits for limit). The description repeats some of this information (e.g., 'Search songs by title' for query, default values) but adds minimal extra semantics, such as clarifying that hidden=true means hidden songs and false means visible only. This meets the baseline for high schema coverage.

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

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

The description clearly states the verb ('List') and resource ('songs in the Planning Center Services song library'), making the purpose immediately understandable. However, it doesn't differentiate this tool from other list tools in the sibling set (like pco_list_people, pco_list_groups, etc.), which would require mentioning the specific domain context of songs versus other Planning Center entities.

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 any prerequisites, context for when listing songs is appropriate, or how it differs from other song-related tools (though none appear in the sibling list). The agent must infer usage from the tool name alone.

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

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

The description adds valuable behavioral context beyond what annotations provide: it specifies the return format options, describes what information is returned (name, schedule type, rehearsal team status), and documents the specific error case ('Error: Resource not found'). While annotations already indicate this is a safe, read-only operation, the description enhances understanding of the tool's behavior.

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

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

The description is well-structured with clear sections for Args and Returns, but includes some redundancy with the schema (e.g., repeating parameter descriptions). The core purpose is stated upfront, and the information is organized logically, though it could be more concise by avoiding duplication of schema details.

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

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

Given the comprehensive annotations (readOnlyHint, openWorldHint, idempotentHint, destructiveHint), 100% schema coverage, and the detailed description of returns and errors, this description provides complete context for a list operation. The absence of an output schema is compensated by the clear return description in the tool description.

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

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

With 100% schema description coverage, the schema already documents all parameters thoroughly. The description repeats some parameter information but doesn't add significant semantic value beyond what's in the schema. It does provide the helpful tip about obtaining service_type_id from another tool, but this is more usage guidance than parameter semantics.

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

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

The description clearly states the verb ('List') and resource ('teams'), specifies the context ('for a specific service type in Planning Center Services'), and distinguishes from siblings by focusing on teams rather than other entities like people, groups, or donations. It provides specific scope information that differentiates it from other list tools.

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

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

The description provides clear context about when to use this tool ('for a specific service type') and mentions prerequisites ('get this from pco_list_service_types'), but doesn't explicitly state when NOT to use it or name specific alternatives among the sibling tools. The guidance is helpful but doesn't fully cover all usage scenarios.

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

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

The description adds valuable behavioral context beyond annotations: it explains the sparse update/PATCH semantics, specifies the return format ('Confirmation and the updated person record'), and details error behavior ('Error: Resource not found' for invalid ID). Annotations cover safety (readOnlyHint=false, destructiveHint=false) and idempotency, but the description complements this with practical implementation details.

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

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

The description is well-structured and front-loaded with the core purpose, followed by sparse update semantics, parameter details, and return/error info. It's efficient but could be slightly more concise by avoiding duplication of schema details in the Args section.

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 mutation nature (annotations show readOnlyHint=false), lack of output schema, and 8 parameters, the description is quite complete. It covers purpose, behavioral traits (sparse update, returns, errors), and parameter context. It could improve by mentioning authentication or rate limits, but it's sufficient 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?

Schema description coverage is 100%, so the schema already documents all parameters thoroughly. The description repeats some parameter info (e.g., format for birthdate, enum values for gender/status) but doesn't add significant new semantics beyond what's in the schema. This meets the baseline for high schema coverage.

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

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

The description clearly states the specific action ('Update an existing person record'), the target resource ('in Planning Center People'), and distinguishes it from siblings like pco_create_person (creation) and pco_get_person (retrieval). It's precise about what the tool does.

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 (updating existing person records) and implies when not to use it (e.g., for creation, use pco_create_person). However, it doesn't explicitly name alternatives or provide detailed exclusions beyond the sparse update semantics.

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