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

With no annotations provided, the description carries the full burden of behavioral disclosure. It mentions the tool is for inspection/lookup, which implies read-only behavior, but doesn't explicitly state this is a safe read operation, doesn't mention authentication requirements, rate limits, or what the output format looks like. For a tool with 4 parameters and no annotation coverage, this leaves significant behavioral gaps.

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

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

The description is perfectly concise with two sentences that each earn their place: the first states the core functionality, the second provides usage context. It's front-loaded with the main purpose and wastes no words.

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

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

Given the tool's complexity (4 parameters, no annotations, no output schema), the description is incomplete. It doesn't explain what the tool returns, how pagination works with limit/page, the search functionality, or the relationship between parameters. For a catalog browsing tool with multiple parameters, this leaves too many gaps for effective agent use.

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

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

Schema description coverage is 0%, so the description must compensate for undocumented parameters. The description mentions 'search' functionality implicitly ('confirm the exact name/ID') but doesn't explain any of the 4 parameters: what 'resource' selection does, how 'search' works, what 'limit' and 'page' control, or their relationships. This adds minimal value beyond the bare 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 inspecting Monica lookup catalogs and lists specific examples (genders, countries, etc.), which is a specific verb+resource combination. However, it doesn't explicitly distinguish this read-only catalog browsing from sibling tools that manage those same resources (like monica_manage_contact_field_type or monica_manage_activity_type), missing full sibling differentiation.

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

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

The description provides clear context for when to use this tool ('when you need to confirm the exact name/ID before performing other actions'), which implicitly suggests it's for lookup/validation before mutations. However, it doesn't explicitly state when NOT to use it or name specific alternative tools for different scenarios, 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?

No annotations are provided, so the description carries the full burden. It mentions verifying credentials but doesn't disclose behavioral traits such as what happens on failure (e.g., error messages), whether it's safe (non-destructive), or any rate limits. For a connectivity test tool with zero annotation coverage, this is a significant gap in transparency.

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

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

The description is a single, efficient sentence: 'Verify that the configured Monica credentials work.' It's front-loaded with the core purpose, has zero waste, and is appropriately sized for a simple tool. Every word earns its place, making it highly concise and well-structured.

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

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

Given the tool's low complexity (0 parameters, no output schema, no annotations), the description is minimally complete. It states the purpose but lacks details on behavior, error handling, or output format. For a connectivity test, more context on what 'verify' entails (e.g., returns success/failure status) would improve completeness, but it's adequate for basic understanding.

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

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

The tool has 0 parameters, and schema description coverage is 100%, so there's no need for parameter details in the description. The description doesn't add parameter semantics, but with no parameters, the baseline is 4, as it adequately addresses the lack of inputs without unnecessary elaboration.

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: 'Verify that the configured Monica credentials work.' It uses specific verbs ('verify') and identifies the resource ('Monica credentials'), making it easy to understand what the tool does. However, it doesn't explicitly differentiate from sibling tools, which are all Monica-related but serve different functions (e.g., managing contacts, activities).

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—testing connectivity when credentials are configured—but doesn't explicitly state when to use this tool versus alternatives. It lacks guidance on prerequisites (e.g., after setup) or exclusions (e.g., not for data operations). Sibling tools are all for data management, so this stands out as a diagnostic tool, but no direct comparison is provided.

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

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

With no annotations provided, the description carries the full burden of behavioral disclosure. It mentions pagination and filtering options, but fails to describe critical behaviors like authentication requirements, rate limits, error handling, or what the response format looks like. This leaves significant gaps for a tool with multiple parameters and no output schema.

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

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

The description is perfectly concise with two well-structured sentences that front-load the core purpose and efficiently detail parameter semantics. Every word earns its place with zero wasted text.

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

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

Given the tool's complexity (4 parameters, nested objects, no annotations, no output schema), the description provides adequate basic context about purpose and parameters but lacks sufficient behavioral information. It doesn't explain what the tool returns, error conditions, or operational constraints, making it incomplete for safe and effective use.

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

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

With 0% schema description coverage, the description compensates well by explaining the meaning of key parameters: it clarifies 'detailLevel' options (minimal/basic/expanded/full) and describes 'filters' content (gender, tags, communication details). However, it doesn't cover 'limit' and 'page' parameters, leaving some gaps in parameter understanding.

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

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

The description clearly states the specific verb ('Retrieve') and resource ('paginated list of contacts'), distinguishing it from sibling tools like 'monica_search_contacts' by explicitly noting it works 'without requiring a search query'. This provides precise differentiation and purpose.

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

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

The description provides clear context by stating this tool is for listing contacts 'without requiring a search query', which implicitly suggests using 'monica_search_contacts' when a search query is needed. However, it lacks explicit when-not-to-use guidance or alternative naming for all scenarios.

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

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

With no annotations provided, the description carries full burden for behavioral disclosure. It mentions the tool can 'create, update, or delete' which implies mutation capabilities, but doesn't disclose permissions needed, whether deletions are permanent, rate limits, or what happens with partial updates. The description is insufficient for a multi-action tool with destructive capabilities.

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

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

The description is appropriately concise with two sentences. The first sentence clearly states the tool's purpose and scope. The second provides specific parameter guidance. There's no wasted language, though it could benefit from better front-loading of key information.

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

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

For a complex tool with 6 parameters, nested objects, multiple actions (including destructive ones), and no output schema, the description is inadequate. It doesn't explain return values, error conditions, or behavioral differences between actions. The lack of annotations exacerbates the incompleteness, leaving the agent with insufficient context for proper tool selection and invocation.

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

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

With 0% schema description coverage, the description adds minimal value beyond the schema. It mentions 'Provide either activityTypeId or activityTypeName' which clarifies a relationship between payload fields, but doesn't explain the purpose of action, activityId, contactId, limit, page, or most payload fields. The description doesn't adequately compensate for the complete lack of schema descriptions.

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

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

The description clearly states the tool's purpose: to 'List, inspect, create, update, or delete activities (meetings, events, shared interactions).' This is a specific verb+resource combination that distinguishes it from siblings like monica_list_contacts or monica_manage_task_reminder. However, it doesn't explicitly differentiate from monica_manage_activity_type, which might cause confusion.

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

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

The description provides no guidance on when to use this tool versus alternatives. It mentions 'Provide either activityTypeId or activityTypeName' but this is parameter guidance, not usage context. There's no indication of when to choose list vs. get vs. create actions, or how this differs from other activity-related tools like monica_manage_call.

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

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

With no annotations provided, the description carries the full burden of behavioral disclosure. While it mentions the CRUD operations, it doesn't address important behavioral aspects like authentication requirements, rate limits, whether deletions are permanent, what happens to existing activities when types are modified, or the response format. For a multi-action tool with destructive operations, this leaves significant gaps.

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

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

The description is perfectly concise with two sentences that each earn their place: the first states the core functionality, the second provides usage context. It's front-loaded with the essential information and contains zero wasted words.

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

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

For a complex tool with 5 parameters, nested objects, multiple actions including destructive operations, and no output schema or annotations, the description is insufficient. It doesn't explain the multi-action nature, parameter dependencies, expected responses, or behavioral implications. The context signals indicate high complexity that the description doesn't adequately address.

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

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

With 0% schema description coverage, the description doesn't add any parameter-specific information beyond what's implied by the tool's purpose. It doesn't explain what 'action' values mean, when 'activityTypeId' is required, how 'limit' and 'page' work for pagination, or what 'payload' contains for create/update operations. The baseline is 3 since the schema provides structure, but the description fails to compensate for the coverage gap.

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 verbs ('List, inspect, create, update, or delete') and resource ('Monica activity types'), plus provides concrete examples ('e.g., Meeting, Coffee, Meal'). It distinguishes this tool from sibling tools like 'monica_manage_activity' by focusing on activity types rather than activities themselves.

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

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

The description provides clear context for when to use this tool ('to expand the catalog with custom activity names before logging activities'), which helps guide usage. However, it doesn't explicitly state when NOT to use it or mention specific alternatives among the sibling tools, preventing 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?

With no annotations provided, the description carries full burden for behavioral disclosure. It mentions 'capture quick notes' which implies creation/update operations, but doesn't clarify permissions needed, whether deletions are permanent, rate limits, or what the response looks like (e.g., format of listed calls). For a multi-action tool with mutations, this is a significant gap in transparency.

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

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

The description is appropriately sized with two sentences: the first lists actions and resource, the second provides a use case. It's front-loaded with the core purpose. While efficient, the second sentence could be more informative, 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 complexity (6 parameters, nested objects, multiple actions including mutations), no annotations, and no output schema, the description is incomplete. It lacks details on behavioral traits, parameter usage, and expected outputs, making it inadequate for an AI agent to reliably invoke this tool without guesswork.

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 0%, so the description must compensate by explaining parameters. It adds no parameter-specific information beyond implying 'contactId' and 'content' might be used for notes. With 6 parameters (including nested 'payload'), the description fails to clarify the meaning of 'action' enum values, 'callId' usage, or pagination details, leaving most semantics undocumented.

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, inspect, create, update, or delete logged phone calls' specifies multiple verbs and the resource (phone calls). It distinguishes from siblings like 'monica_list_contacts' by focusing on calls rather than contacts, but doesn't explicitly differentiate from 'monica_manage_activity' which might handle similar operations for activities.

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

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

The description provides minimal guidance: 'Use this to capture quick notes about conversations with contacts' suggests a use case but doesn't specify when to choose this tool over alternatives like 'monica_manage_activity' for logging interactions, nor does it mention prerequisites or exclusions. No explicit when/when-not or alternative tool references are provided.

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

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

With no annotations provided, the description carries full burden but provides minimal behavioral context. It mentions 'section-based operations' but doesn't explain what happens during create/update/delete actions, whether operations are destructive, what permissions are required, or how errors are handled. For an 11-parameter tool with complex nested objects, this is insufficient behavioral disclosure.

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

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

The description is perfectly concise with two sentences: the first explains the tool's section-based nature with clear examples, the second provides usage guidance with specific alternative tools. Every word earns its place with no redundancy or fluff.

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

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

Given the tool's high complexity (11 parameters, nested objects, multiple actions), no annotations, and no output schema, the description is incomplete. It explains the section parameter well but leaves most parameters undocumented, provides minimal behavioral context for a multi-action tool, and doesn't address return values or error conditions.

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

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

With 0% schema description coverage and 11 parameters (including complex nested objects), the description only explains the 'section' parameter's four enum values. It doesn't clarify when other parameters like contactId, contactFieldId, addressId, or the three payload objects are required, nor their relationships to sections and actions. The description adds minimal value beyond what the bare schema provides.

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

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

The description clearly states this is an 'Advanced contact management tool with section-based operations' and specifies the four section types (summary, profile, field, address) with their purposes. It distinguishes this comprehensive tool from its simpler wrapper siblings by explicitly naming them as alternatives.

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

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

The description provides explicit guidance on when to use this tool vs alternatives: 'For simpler operations, prefer the dedicated wrapper tools' and names three specific alternatives (monica_manage_contact_profile, monica_manage_contact_field, monica_manage_contact_address). This gives clear direction on tool selection.

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

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

With no annotations provided, the description carries the full burden of behavioral disclosure. It mentions the multi-action nature (list/get/create/update/delete) and the automatic country lookup feature, which adds useful context. However, it doesn't cover important behavioral aspects like authentication requirements, error handling, rate limits, or what happens during delete operations, leaving significant gaps for a tool with mutation capabilities.

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 in two sentences: the first states the purpose and usage guidance, the second provides parameter guidance. Every sentence adds value with zero wasted words, making it easy to parse 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 multi-action tool with 6 parameters, 0% schema description coverage, no annotations, and no output schema, the description provides good purpose and usage guidance but lacks sufficient behavioral context (especially for mutation operations) and doesn't fully compensate for the missing parameter documentation. The automatic country lookup hint is helpful but doesn't make up for other 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?

With 0% schema description coverage, the description provides valuable parameter context by explaining that 'contactId and addressPayload with name, street, city, province, postalCode, and countryName' are needed, and that 'country lookup is automatic.' This clarifies the purpose of key parameters beyond what the bare schema provides, though it doesn't cover all 6 parameters or explain the action enum values.

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

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

The description clearly states the tool's purpose with specific verbs ('list, get, create, update, or delete') and resource ('contact addresses'), distinguishing it from the sibling tool 'monica_manage_contact' by explicitly positioning it as a simplified alternative for address management. This provides precise differentiation.

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

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

The description explicitly states when to use this tool ('Use this simplified tool instead of monica_manage_contact when managing addresses'), providing clear guidance on alternatives and context. This helps the agent choose between sibling tools effectively.

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

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

With no annotations provided, the description carries the full burden of behavioral disclosure. It mentions the CRUD actions but lacks critical behavioral details: it doesn't specify permissions required, whether deletions are permanent, rate limits, error handling, or what the tool returns. For a multi-action tool with no annotation coverage, this leaves significant gaps in understanding how the tool behaves beyond basic functionality.

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

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

The description is appropriately sized with two sentences. The first sentence clearly states the purpose and scope, while the second provides usage guidance and parameter hints. There's minimal redundancy, and information is front-loaded effectively. It could be slightly more structured by separating parameter guidance into a distinct section, but overall it's efficient.

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

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

Given the tool's complexity (6 parameters with nested objects, multiple actions including destructive operations like delete), no annotations, and no output schema, the description is inadequate. It doesn't explain return values, error conditions, authentication needs, or the full behavioral implications of different actions. For a multi-operation tool with significant parameter complexity, this leaves too many unknowns for effective agent use.

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

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

Schema description coverage is 0%, so the description must compensate. It mentions 'contactId and fieldPayload with data and contactFieldTypeName (e.g., "Email", "Phone")', which adds some semantic context for 3 parameters. However, it doesn't explain the 'action' enum values, 'contactFieldId', 'limit', or 'page' parameters, nor does it clarify the relationship between 'contactFieldTypeId' and 'contactFieldTypeName' in the nested object. The description adds partial value but doesn't fully compensate for the schema coverage gap.

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, get, create, update, or delete contact fields like email addresses, phone numbers, social media handles, etc.' It specifies the verb (manage) and resource (contact fields) with concrete examples. However, it doesn't explicitly differentiate from sibling tools beyond mentioning 'monica_manage_contact' as an alternative for field management, missing comparisons with other field-related tools like 'monica_manage_contact_field_type'.

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

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

The description provides explicit guidance: 'Use this simplified tool instead of monica_manage_contact when managing contact fields.' This clearly indicates when to use this tool versus a specific alternative. However, it doesn't mention when NOT to use it (e.g., for other contact aspects) or compare it to other field-related siblings like 'monica_manage_contact_field_type', leaving some contextual gaps.

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

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

No annotations are provided, so the description carries the full burden. It mentions actions like 'create, update, or delete' but does not disclose behavioral traits such as permissions required, whether deletions are permanent, rate limits, or response formats. This is a significant gap for a multi-action tool with potential destructive operations.

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

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

The description is concise and front-loaded, stating the core actions and purpose in the first sentence. The second sentence adds usage context without redundancy. It is appropriately sized for the tool's complexity, though it could be slightly more detailed given the lack of annotations and schema 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 complexity (5 parameters, nested objects, multiple actions including destructive ones), no annotations, and no output schema, the description is incomplete. It lacks details on behavioral aspects, parameter meanings, and expected outcomes, making it inadequate for safe and effective use by an AI agent.

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

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

Schema description coverage is 0%, so the description must compensate. It does not explain any parameters (e.g., 'action', 'contactFieldTypeId', 'payload') or their semantics. The description only hints at use cases ('social accounts or custom data') without clarifying how parameters relate to actions, failing to add meaningful context beyond the bare 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: 'List, inspect, create, update, or delete contact field types' with examples like 'Email, Twitter, Instagram'. It specifies the resource (contact field types) and the actions, but does not explicitly differentiate from sibling tools like 'monica_manage_contact_field', which might handle individual field values rather than 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 some guidance: 'Use this when you need new field types for social accounts or custom data.' This implies usage for creating or managing field types, but it does not specify when to use this tool versus alternatives (e.g., 'monica_manage_contact_field' for actual field data) or list exclusions, leaving room for ambiguity.

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

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

With no annotations provided, the description carries full burden for behavioral disclosure. While it mentions the three actions (create/update/delete), it doesn't explain permission requirements, whether deletions are permanent, how updates handle missing fields, or error conditions. For a mutation tool with zero annotation coverage, this leaves significant behavioral gaps.

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

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

The description is efficiently structured in two sentences: first states purpose and sibling differentiation, second provides parameter guidance. Every sentence adds value, though it could be slightly more front-loaded with critical behavioral information given the mutation nature.

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

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

For a mutation tool with 3 parameters (including complex nested objects), 0% schema description coverage, no annotations, and no output schema, the description is incomplete. It doesn't explain what happens during different actions, what the tool returns, or how to handle the profile object's many fields beyond the few mentioned.

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

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

The description mentions key parameters (firstName, lastName, nickname, description, genderName, birthdate) and notes gender is optional. However, with 0% schema description coverage and 3 total parameters (including complex nested objects), the description doesn't fully explain the action enum, contactId usage, or the profile object structure. It adds some value but doesn't compensate for the complete schema coverage gap.

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: 'Create, update, or delete a contact profile.' It specifies the resource (contact profile) and distinguishes it from sibling 'monica_manage_contact' by noting this is a 'simplified tool' for profiles specifically.

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

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

The description provides explicit guidance: 'Use this simplified tool instead of monica_manage_contact when working with contact profiles.' This directly tells the agent when to use this tool versus a key alternative, fulfilling the highest scoring criteria.

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

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

No annotations are provided, so the description carries the full burden. It mentions the actions (list, append, remove) which implies read and write operations, but does not disclose behavioral traits such as permission requirements, whether changes are reversible, rate limits, or error handling. For a mutation tool with zero annotation coverage, this is a significant gap.

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

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

The description is front-loaded with the core purpose and efficiently uses two sentences to explain parameter usage without redundancy. Every sentence adds value, making it appropriately sized and well-structured for quick comprehension.

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

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

Given the complexity (4 parameters, no annotations, no output schema), the description is adequate but incomplete. It covers the basic purpose and parameter semantics, but lacks details on behavioral aspects, error cases, or output format. For a tool with mutation capabilities and no structured support, it meets minimum viability but has clear gaps.

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

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

With 0% schema description coverage, the description compensates by explaining the semantics of parameters: it clarifies that tagNames are used for adding new/existing tags, while tagIds/tagNames are for removal, and implies action and contactId are required. This adds meaningful context beyond the bare schema, though it doesn't cover all parameter details like formats or constraints.

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 actions (list, append, remove) and resource (tags on a specific contact), distinguishing it from sibling tools like monica_manage_contact (general contact management) and monica_manage_tag (tag management). It uses precise verbs and specifies the target resource explicitly.

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 on when to use different parameters (e.g., tagNames for adding, tagIds/tagNames for removing), but does not explicitly state when to use this tool versus alternatives like monica_manage_contact or monica_manage_tag for broader operations. It implies usage through parameter guidance but lacks 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?

With no annotations provided, the description carries full burden for behavioral disclosure. While it lists the available actions, it doesn't explain what each action does, what permissions are required, whether operations are destructive, what happens to related data, or what the response format looks like. For a tool with 8 parameters including nested objects and multiple mutation actions, this is a significant gap in behavioral context.

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

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

The description is reasonably concise with two sentences, but the structure could be improved. The first sentence tries to cover too many actions (list, inspect, create, update, delete, manage) which makes it somewhat vague. The second sentence provides specific parameter guidance but feels tacked on rather than integrated. While not verbose, it lacks the front-loaded clarity that would help an agent quickly understand the tool's core function.

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

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

Given the tool's complexity (8 parameters including nested objects, multiple actions including mutations), lack of annotations, and no output schema, the description is inadequate. It doesn't explain the relationship between conversation and message operations, doesn't provide examples of when to use different actions, and doesn't cover error conditions or response formats. For a multi-action tool with significant parameter complexity, this description leaves too much unexplained.

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 0%, so the description must compensate. It only mentions two parameters (contactFieldTypeId or contactFieldTypeName) out of 8 total parameters. It doesn't explain the relationship between action and required parameters, what payload and messagePayload contain, or how conversationId, messageId, contactId, limit, and page are used. The description adds minimal value beyond what the bare schema provides.

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

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

The description clearly states the tool's purpose with specific verbs (list, inspect, create, update, delete, manage) and resource (Monica conversations). It distinguishes from sibling tools like monica_list_contacts and monica_manage_contact by focusing specifically on conversations rather than contacts or other entities. However, it doesn't explicitly differentiate from monica_manage_activity which might also involve conversation-like interactions.

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

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

The description provides minimal usage guidance. It mentions 'Provide either contactFieldTypeId or contactFieldTypeName for the channel' which is a parameter requirement, but doesn't explain when to use this tool versus alternatives like monica_manage_contact or monica_manage_activity. There's no guidance on which action to choose for specific scenarios, nor any prerequisites or constraints for using different actions.

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

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

With no annotations provided, the description carries full burden for behavioral disclosure. While it mentions the five possible actions, it doesn't describe permissions needed, whether deletions are permanent, rate limits, error conditions, or what happens when creating/updating records. For a multi-action tool with destructive operations, this leaves significant gaps.

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

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

The description is perfectly concise with two sentences that each earn their place. The first sentence states the core functionality, and the second provides essential parameter guidance. There's zero wasted text and it's front-loaded with the most important information.

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

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

Given the tool's complexity (8 parameters, multiple actions including destructive operations, nested objects), no annotations, and no output schema, the description is insufficient. It doesn't explain how different actions map to different parameter requirements, what the tool returns, or behavioral constraints. For a multi-purpose CRUD tool, this leaves too many questions unanswered.

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

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

The description adds meaningful context for the recordType parameter by explaining what 'gift' and 'debt' represent. However, with 8 total parameters and 0% schema description coverage, it doesn't explain the purpose of action, recordId, contactId, limit, page, giftPayload, or debtPayload. The description provides some value but doesn't compensate for the extensive coverage gap.

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 verbs ('list, inspect, create, update, or delete') and resources ('gifts and debts'), and distinguishes it from siblings by focusing on financial records rather than contacts, activities, or other entities. The explanation of recordType values further clarifies the scope.

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

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

The description provides clear context for when to use specific recordType values ('gift' for presents, 'debt' for money owed), which helps guide parameter selection. However, it doesn't explicitly state when to use this tool versus alternatives like monica_manage_contact or other sibling tools for related data.

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

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

No annotations are provided, so the description carries the full burden of behavioral disclosure. While it lists the actions (list, inspect, create, update, delete), it does not disclose critical behavioral traits such as permissions required, whether deletions are permanent, rate limits, or what 'inspect' entails. For a multi-action tool with potential destructive operations, this is a significant gap.

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

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

The description is front-loaded with the core purpose in the first sentence and adds a practical example in the second. Every sentence earns its place by clarifying usage without redundancy, making it appropriately sized and efficient.

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

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

Given the complexity of a multi-action tool (including destructive operations like delete), no annotations, no output schema, and 0% schema description coverage, the description is incomplete. It lacks details on behavioral traits, parameter usage, and expected outputs, which are essential for safe and effective tool invocation.

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

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

The description does not mention any parameters, and schema description coverage is 0%, so it adds no semantic information beyond the schema. However, the schema itself is well-structured with clear properties (action, groupId, limit, page, payload), and the action enum provides context. The baseline score of 3 reflects that the schema does the heavy lifting, but the description fails to compensate for the coverage gap.

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 actions (list, inspect, create, update, delete) and resource (contact groups), with a concrete example ('Family', 'Travel buddies') that distinguishes it from sibling tools like monica_list_contacts or monica_manage_contact_tags. It goes beyond the tool name/title by explaining the organizational purpose.

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

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

The description provides clear context for when to use this tool ('organize contacts into named collections'), which implicitly distinguishes it from sibling tools that manage other resources (e.g., contacts, tags, activities). However, it does not explicitly state when NOT to use it or name specific alternatives, such as when to use monica_manage_contact_tags instead for tagging versus grouping.

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

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

With no annotations provided, the description carries full burden for behavioral disclosure. It lists actions (list, inspect, upload, delete) but fails to describe critical traits: permissions required for upload/delete, rate limits, whether deletions are permanent, response formats, or error handling. For a multi-action tool with mutation capabilities, this leaves significant gaps.

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

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

The description is appropriately concise with two sentences that front-load the core actions. Every word earns its place, though it could be more structured by separating actions from guidance. No wasted verbiage.

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

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

Given the tool's complexity (10 parameters, multiple actions including mutations), lack of annotations, and no output schema, the description is incomplete. It doesn't cover behavioral aspects, parameter dependencies, or expected outputs, leaving the agent poorly equipped to use this tool correctly.

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

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

Schema description coverage is 0%, so the description must compensate but adds minimal value. It mentions mediaType to 'pick the resource' but doesn't explain the action parameter's role, when mediaId/contactId are needed, or how filePath/base64Data/fileName/mimeType interact for uploads. With 10 parameters and no schema descriptions, this is inadequate.

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 verbs (list, inspect, upload, delete) and resources (documents and photos stored in Monica). It distinguishes this tool from siblings like monica_list_contacts or monica_manage_note by focusing on media management. However, it doesn't explicitly differentiate from all siblings beyond the resource scope.

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

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

The description provides minimal guidance with 'Use mediaType to pick the resource,' but offers no explicit when-to-use criteria, no exclusions, and no alternatives. It doesn't explain when to choose this tool over other monica_manage_* tools or how it relates to siblings like monica_manage_contact (which might handle contact-specific media).

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

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

No annotations are provided, so the description carries the full burden of behavioral disclosure. It mentions actions like 'create, update, or delete' which imply mutations, but does not disclose permissions needed, rate limits, error handling, or what happens on deletion (e.g., irreversible). For a multi-action tool with potential destructive operations, this is a significant gap.

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

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

The description is appropriately sized and front-loaded, with two concise sentences that directly state the tool's purpose and usage. Every sentence earns its place without redundancy or unnecessary details.

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

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

Given the tool's complexity (6 parameters, nested objects, multiple actions including destructive ones) and lack of annotations and output schema, the description is incomplete. It does not cover behavioral aspects like safety, return values, or parameter dependencies, leaving significant gaps for an AI agent to use it correctly.

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

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

Schema description coverage is 0%, so the description must compensate. It does not explain any parameters, such as the meaning of 'action' enum values, when 'noteId' or 'contactId' are required, or what 'payload' contains. The description adds no parameter semantics beyond what the schema provides, but the schema itself is detailed with enums and constraints, providing a baseline.

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

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

The description clearly states the tool's purpose with specific verbs ('list, inspect, create, update, or delete') and resource ('notes attached to a contact'), and distinguishes it from siblings by focusing on notes rather than contacts, activities, or other entities. The phrase 'capture or revise journal snippets' adds useful context about the nature of notes.

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

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

The description provides clear context for usage ('to capture or revise journal snippets'), but does not explicitly state when to use this tool versus alternatives like sibling tools for managing contacts or activities. It implies usage for note-related operations without specifying exclusions or comparisons.

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

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

With no annotations provided, the description carries the full burden of behavioral disclosure. It mentions actions like create, update, and delete, implying mutations, but fails to describe permissions, side effects, error handling, or response formats. This is a significant gap for a multi-action tool with potential destructive operations.

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 and adds a brief usage note in the second. It avoids redundancy and is appropriately sized, though it could be slightly more structured to separate actions from parameters.

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

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

Given the tool's complexity (6 parameters, nested objects, multiple actions including mutations) and lack of annotations and output schema, the description is incomplete. It does not cover behavioral aspects, parameter details, or return values, making it inadequate for safe and effective use by an AI agent.

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

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

The description adds minimal semantics by mentioning relationshipTypeId or relationshipTypeName, which maps to one parameter in the nested payload. However, with 0% schema description coverage and 6 total parameters, it does not compensate for the lack of schema documentation. The baseline is 3 as it provides some context but leaves most parameters unexplained.

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 verbs ('List, inspect, create, update, or delete') and resource ('relationships between contacts'), distinguishing it from siblings like monica_list_contacts or monica_manage_contact. It explicitly mentions the scope of operations, making the purpose unambiguous.

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

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

The description implies usage by mentioning relationshipTypeId or relationshipTypeName for identification, but it does not provide explicit guidance on when to use this tool versus alternatives (e.g., monica_manage_contact for contact-level operations). No exclusions or prerequisites are stated, leaving usage context partially inferred.

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

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

No annotations are provided, so the description carries the full burden of behavioral disclosure. It mentions the actions (list, inspect, create, update, delete) but fails to detail critical traits like authentication requirements, rate limits, error handling, or the effects of destructive actions (e.g., deletion permanence). For a multi-action tool with no annotation coverage, this is a significant gap.

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

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

The description is appropriately sized and front-loaded, consisting of two concise sentences that directly state the tool's purpose and function without unnecessary details. Every sentence earns its place by providing essential information efficiently.

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

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

Given the tool's complexity (5 parameters, multiple actions including destructive ones), lack of annotations, and no output schema, the description is incomplete. It does not cover behavioral aspects, parameter usage, or return values, leaving significant gaps for the agent to operate effectively in this 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 0%, so the description must compensate for undocumented parameters. It implies the 'action' parameter through the listed verbs but does not explain the semantics of other parameters like 'tagId', 'limit', 'page', or 'payload'. The description adds minimal value beyond what the schema's property names suggest, resulting in a baseline score due to incomplete parameter guidance.

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 'List, inspect, create, update, or delete tags' with the specific resource 'tags' and mentions their function 'to group and categorize contacts.' It distinguishes itself from sibling tools like 'monica_manage_contact_tags' by focusing on tag management rather than contact-tag relationships, but does not explicitly contrast with other tag-related tools if any exist.

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 'monica_manage_contact_tags' for managing tags on contacts or other tag-related operations. It lacks explicit context, prerequisites, or exclusions, leaving the agent to infer usage based on the action parameter alone.

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

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

With no annotations provided, the description carries the full burden of behavioral disclosure. While it lists the possible actions (list, get, create, update, delete), it doesn't describe what these operations actually do, their side effects, authentication requirements, rate limits, or response formats. For a tool with 10 parameters and complex nested objects, this leaves significant behavioral gaps.

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

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

The description is appropriately concise with two sentences that directly address the tool's core functionality. The first sentence states the purpose, and the second provides the key parameter guidance. There's no wasted text, though it could be slightly more structured for a tool of this 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 tool's complexity (10 parameters, nested objects, no output schema, and no annotations), the description is incomplete. It doesn't explain how the various parameters interact, what the different actions actually do, what the tool returns, or how to handle the payload objects. For a multi-function tool with significant parameter complexity, this description leaves too many questions unanswered.

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

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

With 0% schema description coverage and 10 parameters, the description adds minimal value beyond what the schema provides. It only explains the semantics of 'itemType' (task vs reminder) and mentions 'action' implicitly through the opening verb list. The other 8 parameters (taskId, reminderId, contactId, status, limit, page, taskPayload, reminderPayload) receive no explanation in the description, leaving their purposes unclear.

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 'List, inspect, create, update, or delete Monica tasks and reminders,' which is a specific verb+resource combination. It distinguishes between tasks and reminders by explaining 'itemType="task" for to-dos or itemType="reminder" for stay-in-touch nudges.' However, it doesn't explicitly differentiate this tool from its siblings like monica_manage_activity or monica_manage_note, which prevents a score of 5.

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

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

The description provides implied usage guidance by explaining when to choose 'task' vs 'reminder' item types, but it doesn't offer explicit when-to-use or when-not-to-use instructions relative to sibling tools. There's no mention of alternatives or prerequisites, leaving the agent to infer usage from the action and itemType parameters alone.

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

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

With no annotations provided, the description carries the full burden of behavioral disclosure. It describes the search functionality and output format ('Returns contact IDs and basic info'), which is helpful. However, it lacks details on permissions, rate limits, pagination behavior (implied by 'page' parameter but not explained), or error handling, leaving gaps for a tool with 4 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 appropriately sized with two sentences: the first states the purpose and output, and the second provides usage guidance. Every sentence earns its place by adding value without redundancy, making it front-loaded and efficient.

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

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

Given the complexity (4 parameters, 0% schema coverage, no annotations, no output schema), the description is partially complete. It covers the purpose and basic usage but lacks details on parameter semantics, behavioral traits like pagination or errors, and output specifics, leaving gaps that could hinder an AI agent's correct invocation.

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

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

The schema description coverage is 0%, so the description must compensate. It implies the 'query' parameter ('Search... by name, nickname, or email') but does not explain the semantics of 'limit', 'page', or 'includePartial'. The description adds some value by clarifying the search scope, but does not fully compensate for the low schema coverage, resulting in a baseline 3.

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

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

The description clearly states the tool's purpose with specific verbs ('Search Monica CRM contacts') and resources ('contacts'), and distinguishes it from sibling tools by specifying search criteria ('by name, nickname, or email') and output ('Returns contact IDs and basic info'), unlike the generic 'monica_list_contacts'.

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 ('Search... by name, nickname, or email') and hints at alternatives by mentioning using returned IDs with other tools for details or updates. However, it does not explicitly state when NOT to use it or name specific alternative tools like 'monica_list_contacts'.

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