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

Annotations already declare readOnlyHint=true, idempotentHint=true, and destructiveHint=false, so the safety profile is fully covered. The description adds that the tool reads 'configuration' of a 'connected' channel, which is mildly useful context, but it does not disclose behavior such as error cases, authorization requirements, or response shape. With annotations covering the main behavioral traits, a 3 is appropriate.

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

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

One sentence, front-loaded with the core action and resource, followed by a brief illustrative use case. Every part earns its place, and there is no redundant restatement of the schema or annotations.

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

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

For a single-parameter read tool with strong annotations and no output schema, the description is sufficient for an agent to know what to call and why. It could be more complete by hinting at the return value, but the phrase 'configuration' already implies what will be returned, so nothing critical is missing.

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%, and the single parameter channel_id is already well documented with a format pattern and an example reference to list_channels. The description adds no new parameter-level meaning beyond the schema, so the baseline 3 applies.

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

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

The description uses a specific verb ('Read') and resource ('one connected channel's configuration') and identifies the lookup key ('by ID'). It is clearly distinct from sibling tools like list_channels and get_conversation, so an agent can tell what this tool does without inspecting its schema.

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 gives a concrete use case: 'before choosing a channel for a message.' This provides clear context for when to call the tool, though it does not explicitly name alternatives or state when not to use it. That is a minor gap given the many sibling get_* 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?

The annotations already declare readOnlyHint=true, idempotentHint=true, and destructiveHint=false, covering the safety profile. The description adds useful behavioral context by explaining why a read is necessary before update_contact, clarifying that update_contact replaces full handle and attribute arrays rather than merging them.

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

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

Two sentences carry the full message with no filler. The primary action is front-loaded, and the update-related guidance is placed second as a concise, high-value note.

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

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

For a single-parameter read tool with annotations covering safety and idempotence, the description is complete: it identifies the input (contact ID), the output scope (details, handles, custom attributes), and the key usage context (before update_contact). No output schema is present, but the description names the returned data categories.

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 provides 100% coverage of the only parameter, contact_id, with a pattern, length constraints, and an example referencing list_contacts and search_contacts. The description adds no new parameter-level detail, so the baseline of 3 is appropriate.

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

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

The description states a specific verb ('Read'), a clear resource ('one contact's details, handles and custom attributes'), and the lookup mechanism ('by ID'). This distinguishes it from list_contacts and search_contacts, which return collections, and from other get_* siblings that target different resources.

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

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

The description explicitly tells the agent to use this tool before update_contact, with a concrete reason: supplied handle and attribute arrays replace their full lists. It does not mention alternatives such as list_contacts or search_contacts, but the use-before-update guidance is specific and actionable.

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 readOnly, idempotent, and non-destructive behavior. The description adds that it does not return participants, which is valuable behavioral context beyond the annotations. It also clarifies the returned metadata fields (ID, name, URL). No contradiction 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?

Two concise sentences. The first states the core action and return content; the second immediately clarifies a potential confusion by naming the alternative. No filler, information is front-loaded.

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

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

For a simple get-by-ID tool with comprehensive annotations, the description fully covers what the tool does, what it returns, and what it does not return. No output schema exists, but the description's mention of ID, name, and URL suffices. Nothing essential is missing.

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 covers 100% of the parameter, and the single parameter contact_list_id is well-documented with a pattern and example. The tool description adds no additional parameter semantics, so the baseline of 3 is appropriate.

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

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

The description states a clear verb ('Read'), a specific resource ('contact list's metadata'), and the selection mechanism ('by ID'). It explicitly distinguishes itself from list_contact_lists_for_contact by noting it does not return participants, which differentiates it from a sibling that might otherwise be confused.

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

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

It provides an explicit when-not: 'use list_contact_lists_for_contact for a contact's memberships.' This gives the agent a clear alternative for a specific scenario, and the naming context implies this tool is for retrieving a single list's metadata by ID versus listing all lists.

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

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

Annotations already declare readOnlyHint, openWorldHint, idempotentHint, and destructiveHint=false, so the safety profile is known. The description adds value by specifying the exact fields returned and the nuance that conversation status does not dictate the channel's messaging window. This is useful behavioral context beyond what annotations provide, though it doesn't mention error handling or return format, which are minor given the low complexity.

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

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

The description is two sentences, front-loaded with the main purpose, and each sentence carries distinct value: the first states what the tool reads, the second gives a routing hint and a clarification. There is zero redundancy or filler. It is efficient 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?

For a simple get-by-ID tool with one parameter and no output schema, the description adequately covers what data is returned and clarifies a common misconception. It doesn't describe the exact JSON response structure, but that's not necessary for a read operation. It also mentions the message history alternative, which helps set expectations. Overall, the tool is well-specified for an agent to call it correctly.

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

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

Schema description coverage is 100% and the parameter's description in the schema already explains the format and gives examples of where to obtain an ID. The tool description adds no additional meaning about the parameter beyond what the schema provides. Since the schema is thorough, the baseline of 3 applies; there is no need for the description to compensate.

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 reads a single conversation thread and lists the specific fields it returns (contact, channel, inbox, status, and messaging time window). It distinguishes itself from siblings by explicitly naming list_conversation_messages for message history and clarifying the status/messaging window relationship, so an agent can tell it apart from related get/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?

It provides an explicit alternative: 'Use list_conversation_messages for its message history when Enterprise access is enabled.' This tells the agent when not to use this tool for messages. It also clarifies a common misinterpretation about status vs. messaging window. It doesn't enumerate all possible alternative tools, but the most relevant one is covered, and the tool's purpose makes its own use case obvious.

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, idempotentHint, and destructiveHint=false, so the safety profile is covered. The description adds valuable context: it explains the asynchronous nature, that it returns only a URL, and explicitly excludes file fetching/parsing. This goes beyond the annotations without contradicting them.

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

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

Two concise sentences with no filler. The purpose is front-loaded, the usage condition follows, and the exclusion is clearly stated. Every sentence earns its place.

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

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

For a two-parameter tool with no output schema, the description covers the essential aspects: what it does, when to use it, and what it returns (a download link). It doesn't specify the exact response structure (e.g., whether status is included), but this is a minor gap given the tool's simplicity and the presence of other guidance.

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

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

The schema description coverage is 100%, with both parameters having descriptive text (e.g., 'Export job ID returned by create_conversation_export.'). The description itself does not add further parameter semantics, but since the schema already fully documents them, a baseline score of 3 is appropriate.

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

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

The description clearly states the tool's function: 'Check the status of an asynchronous conversation export job and retrieve its download link.' It uses a specific verb-resource pair (check status, retrieve link) and distinguishes itself from sibling get tools by focusing on export jobs. It is not a tautology and adds meaning beyond the name.

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

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

It explicitly states the prerequisite: 'Use after create_conversation_export;' and clarifies what it does not do: 'returns the URL but does not fetch or parse the file.' This gives clear context and prevents misuse, even though it doesn't name alternative tools, the workflow is unambiguous.

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, idempotentHint, and destructiveHint false, so the safety profile is covered. The description adds the 'internal note' distinction and the explicit non-customer-message clarification, but does not disclose additional behavioral details like return format, errors, or permissions.

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

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

The description is two short sentences with no filler. The primary action is front-loaded, and the clarifying exclusion earns its place by preventing misuse.

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 tool with strong annotations and fully described parameters, the description is nearly complete. It does not describe the return payload, but 'read one internal note' reasonably implies the note content is returned, and no output schema exists to require more.

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%, and both parameters already have meaningful descriptions: note_id is 'an example returned by list_conversation_notes' and conversation_id is 'the conversation containing the note.' The tool description adds only 'by note ID,' so it does not need to compensate for schema 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 states a specific verb and resource: 'Read one internal note from a conversation by note ID.' It also clarifies what the tool is not for with 'This does not retrieve a customer message,' which helps distinguish it from conversation-message retrieval 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 gives clear context for when to use the tool—reading a single internal note by ID—and includes one exclusion ('does not retrieve a customer message'). However, it does not explicitly name alternatives such as list_conversation_notes for finding note IDs or get_conversation for customer messages, leaving some routing 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 the operation read-only, idempotent, and non-destructive. The description adds one useful behavioral clarification—that file contents are not downloaded—which goes beyond the annotations. However, it does not describe return format, error behavior, or other operational details, so the added context is limited.

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

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

The description is two short sentences with no filler. The core action and scope are front-loaded, and the clarifying non-download note earns its place 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?

For a single-parameter, read-only metadata lookup, the description is complete. The schema fully documents the required parameter, and the annotations cover the safety profile. The statement 'This does not download its contents' closes the most likely misuse case, leaving no critical gap for 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?

Schema description coverage is 100%, and the single 'file_id' parameter is already well documented in the schema with format and an example source ('returned by list_files'). The description adds no additional parameter semantics beyond what the schema already provides, so the baseline score of 3 is appropriate.

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

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

The description uses a specific verb ('Read metadata') and a specific resource ('one uploaded file by ID'), and explicitly distinguishes itself from downloading file contents. This makes the tool's purpose unmistakable and separates it from any file-download expectation.

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

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

The description clearly establishes when to use the tool: to read metadata for a file by ID. It also states an implicit when-not ('This does not download its contents'), which helps an agent avoid using it for content retrieval. It does not explicitly name alternative tools, but the context is clear enough.

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

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

Annotations already declare readOnlyHint=true, idempotentHint=true, and destructiveHint=false, so the safety profile is well covered. The description adds no contradictory behavior and correctly frames the operation as a read, but it does not add additional behavioral context such as auth requirements, error cases, or return shape.

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

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

The description is a single, front-loaded sentence with no filler. Every word contributes to identifying the action, the resource, and the input requirement.

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

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

For a simple single-parameter read operation, the description is sufficient even without an output schema. It clearly identifies the resource and input, and the sibling list operation covers the listing alternative. A bit more detail about what 'details' include would push it higher.

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 already covers the single parameter 100%, including a pattern and an example source ('returned by list_inboxes'). The description's 'by ID' adds no semantic detail beyond what the schema provides, so the baseline 3 is appropriate.

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

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

The description uses a specific verb ('Read') and resource ('one inbox's details') with a clear identifier requirement ('by ID'). It is immediately distinguishable from the sibling list operation 'list_inboxes' and from getters of other 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 the use case clearly: when you need details for a specific inbox and already have its ID. It does not explicitly name alternatives or exclusions, but the context is strong enough given the sibling getters and listers.

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

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

Annotations already declare readOnlyHint=true, idempotentHint=true, and destructiveHint=false, covering the safety profile. The description adds the useful domain clarification that labels apply to conversations, not contacts, but does not disclose error behavior or output format.

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

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

Two short sentences with no filler. The core action is front-loaded, and the second sentence adds only a relevant distinction without unnecessary detail.

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

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

For a simple one-parameter read operation with strong annotations, the description is nearly complete. It could mention what a valid label ID looks like or what the response contains, but those are minor gaps given the schema constraints and read-only nature.

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

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

The input schema covers 100% of the single parameter, including a description and an example referencing list_labels. The tool description adds no additional parameter-level meaning, so a baseline score of 3 is appropriate.

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

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

The description uses a specific verb ('Read') and resource ('one conversation label by ID'), making the tool's function immediately clear. It also differentiates labels from contacts, which helps distinguish it from contact-related 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 implies this tool is for fetching a single label by its ID, and the schema's mention of list_labels suggests an obvious companion tool. However, it lacks explicit guidance on when to prefer this tool over list_labels or other label-related operations.

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

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

Annotations already declare readOnlyHint=true, idempotentHint=true, and destructiveHint=false, so the safety profile is covered. The description adds useful context about API-key-to-account association, but it does not describe return shape, error behavior, or authentication requirements beyond what is implied.

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

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

Two sentences with no filler. The core behavior is front-loaded, and the practical use case is stated immediately after, making it easy for an agent to parse quickly.

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

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

For a zero-parameter, read-only identity lookup with rich annotations, the description is complete. It tells the agent what the tool returns (the user associated with the API key) and why it would be used, which is sufficient for 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 input schema has zero parameters and schema description coverage is 100%, so there is nothing for the description to clarify. With no parameters, the baseline is 4, and the description appropriately avoids inventing unnecessary parameter details.

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

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

The description uses a specific verb ('Identify') and a specific resource ('the Superchat user associated with this API key'), which clearly distinguishes it from sibling tools like superchat_get_user that might fetch arbitrary users. It immediately conveys that this is a self-identity lookup for the authenticated API key.

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 the intended use case: 'Use this to confirm which account the server is connected to.' This gives clear context for when to call the tool, though it does not explicitly name alternatives or exclusion 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?

Annotations already declare readOnlyHint, idempotentHint, and non-destructive behavior, so the safety profile is covered. The description adds value by naming the exact fields returned (content, approval status, positional variables) and the intended timing, which is not visible in the schema or annotations. This gives the agent a concrete sense of what the read yields.

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

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

The description is two sentences with no filler. The purpose and output are front-loaded in the first sentence, and the usage rule is in the second. Every word earns its place.

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

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

For a simple one-parameter read tool with rich annotations and no output schema, the description is complete. It states what is read, when to use it, and how it differs from the sibling list_templates. The agent has enough to select and invoke the tool correctly.

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

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

Schema description coverage is 100%, and the schema already documents template_id with format constraints and an example source (list_templates). The description reinforces the 'known ID' context but does not add new parameter-level detail. Baseline 3 is appropriate because the schema carries the semantic weight.

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 names a specific verb ('Read') and resource ('one template's content, approval status and positional variables'), which precisely states what the tool does. It also distinguishes itself from list_templates by focusing on a single known template. This leaves no ambiguity about the tool's 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 explicitly says to use this tool instead of list_templates when the template ID is already known. This gives an agent a clear decision rule and names the alternative. It also adds practical context ('before sending it') that reinforces why retrieval matters.

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

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

Annotations already declare readOnlyHint=true, idempotentHint=true, openWorldHint=true, and destructiveHint=false, so the description need not repeat safety traits. It adds the scoping detail that this reads one workspace user, but does not disclose additional behaviors such as error handling or return format. This is acceptable given the simple read operation and strong annotations.

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

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

The description is a single sentence with no filler. The action, resource, and scope are front-loaded, making it immediately actionable for an 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 get-by-ID tool with one well-documented parameter and annotations covering safety, the description is nearly complete. It does not describe the response shape or not-found behavior, but the low complexity and strong schema/annotation coverage make this a minor gap.

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

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

Schema coverage is 100%, and the user_id parameter already has a description with an example source (list_users). The description's 'by ID' adds no new semantic detail beyond what the schema provides, so the baseline score of 3 is appropriate.

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

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

The description uses a specific verb ('Read'), identifies the resource ('one workspace user's details'), and specifies the access method ('by ID'). This clearly distinguishes it from sibling tools like list_users (which reads all users) and get_me (which reads the current user).

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

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

The description clearly implies the tool is for fetching a single user's details when the user ID is known. It does not explicitly name alternatives or state when not to use it, but the context is clear enough for an agent to select it appropriately.

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 read-only, idempotent, non-destructive behavior. The description adds meaningful behavioral detail beyond that: each call returns only one page, and after/before cursors are needed to continue pagination. This helps the agent understand the tool's paging behavior without relying solely on 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 compact and front-loaded with the core behavior, then adds channel examples, the downstream use of channel_id, and pagination guidance. Every sentence contributes useful information with no unnecessary filler.

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

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

For a simple, read-only list tool with three optional parameters and rich schema descriptions, the description is complete. It covers scope, output relevance (channel_id), and pagination behavior, leaving no critical ambiguity for an agent deciding to call it.

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

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

The input schema already provides thorough descriptions for all three parameters, including cursor usage and the limit range, so schema coverage is 100%. The description reinforces the pagination concept but does not meaningfully extend the 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 identifies the action and resource: 'List one page of connected channels in this workspace.' It also provides concrete examples of channel types (WhatsApp, Instagram Direct, etc.) and notes that returned channel_ids are used for sending, which makes the tool's role unambiguous relative to sibling 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 gives clear context: use this tool to obtain connected channels and channel_ids for sending. It also explains how to use pagination cursors. It does not explicitly name alternatives or say when not to use it, but the intended usage is clear from the description.

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 establish readOnly, idempotent, non-destructive behavior. The description adds useful behavioral context beyond those annotations: output is one page, returns conversation records rather than raw messages, and is scoped across contact channels. No contradiction with annotations. It could also explain pagination mechanics, but the schema already covers cursors.

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

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

Two purposeful sentences: the first states scope and action, the second clarifies output type and points to the message-history alternative. No filler, no restatement of the schema, and the most decision-relevant information is front-loaded.

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

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

Given only one required parameter, high schema coverage, and annotations declaring safety and idempotency, the description is complete for both selection and invocation. It covers page size, scope, output type, and the message alternative; no output schema is needed to explain the return value here.

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?

All four parameters are fully described in the schema (100% coverage), so the description need not add parameter-level detail. It contributes the general context that threads are per contact and across channels, but this doesn't change the baseline of 3 for schema-heavy 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 opens with a specific verb-resource pair — 'List one page of conversation threads for a contact across its channels' — and then draws a hard line between conversation records and message history, which differentiates it from the related list_conversations and list_conversation_messages tools.

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

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

It states when to use the tool ('for a contact'), what it is not for ('Results are conversation records, not message history'), and names the alternative with a condition: 'use list_conversation_messages for messages when Enterprise access is enabled.' This is explicit routing rather than implied guidance.

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

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

Annotations already cover safety (readOnly, idempotent, non-destructive), and the description adds meaningful behavioral detail: each call returns only one page, results contain only metadata, and pagination uses after/before cursors. This goes beyond the structured annotations without contradicting them.

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

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

Three sentences, each earning its place: purpose and scope, result contents and alternative, and pagination behavior. The core purpose is front-loaded and there is no redundant wording.

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

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

The description explains the result content, pagination model, and the relevant sibling alternative. It does not spell out the exact response envelope, but the schema's cursor descriptions and the tool's simple read-only nature make the definition sufficiently complete for 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?

Schema description coverage is 100%, so the schema already defines after, before, and limit precisely. The description reinforces that after/before continue from a previous page and that only one page is returned, which adds some context but does not substantially expand on the parameter definitions.

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

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

The description states a specific verb and resource ('List one page of contact lists') and clearly distinguishes itself from the sibling list_contact_lists_for_contact by noting it returns list metadata rather than contact memberships. This makes the tool's role 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?

It explicitly says to use list_contact_lists_for_contact when needing a contact's memberships, and explains when to use the after/before pagination parameters. This gives an agent clear guidance on when this tool is appropriate and when to select an alternative.

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 discloses that it returns only one page of results, which is a behavioral trait not covered by the annotations (readOnlyHint, openWorldHint, idempotentHint). This adds useful context about pagination. It does not contradict any annotations, and while it doesn't discuss rate limits or auth, those are beyond the scope of this simple read operation.

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

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

Two sentences with no filler. The core action is front-loaded in the first sentence, and the second sentence provides essential usage guidance and sibling differentiation. Every word earns its place.

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

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

The combination of a 100%-covered schema, clear annotations, and the description fully equips an agent to call the tool correctly. The only minor gap is that the description does not specify the exact shape of the response, but there is no output schema and the purpose makes the return type obvious. This is a strong, mostly complete definition.

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 parameters are fully documented in the schema. The description does not add any additional meaning about parameters beyond the schema's coverage; it only restates the purpose of contact_id in prose. Per the calibration baseline for high schema coverage, a 3 is appropriate.

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

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

States a specific action and resource ('List one page of contact lists that contain this contact') and immediately distinguishes itself from sibling tools by noting that list_contact_lists and get_contact_list return only list metadata, not participants. An agent can tell exactly what this tool does and what it doesn't do without opening schemas.

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?

Explicitly says 'Use this to inspect membership' and contrasts against sibling tools that return only metadata, which clearly indicates when to prefer this over the alternatives. It gives a direct use case and implies the condition for choosing the other tools, satisfying the need for when/when-not guidance.

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

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

Annotations already declare readOnlyHint=true, idempotentHint=true, and destructiveHint=false, covering the safety profile. The description adds meaningful behavioral context beyond that: it states the ordering ('newest first') and the pagination behavior ('one page'), which are not in the annotations. This adds value without contradicting the annotations.

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

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

The description is two sentences with zero filler. The primary function is front-loaded, and the alternative-usage note is a single, tightly worded sentence. Every word earns its place.

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

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

For a read-only, paginated list tool, this description is complete. It specifies the ordering, the one-page limitation, and when to use a sibling tool instead. The schema covers parameter details, and the annotations cover safety. Nothing an agent needs to decide whether to call this tool or how to use it correctly is missing.

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

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

Schema coverage is 100% – all three parameters (after, limit, before) have detailed descriptions in the schema. The tool description itself does not add any additional parameter semantics; it only mentions pagination implicitly. Per the rubric, with high schema coverage, the baseline is 3, and the description does not exceed that 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 function: 'List one page of contacts, newest first.' It uses a specific verb (list), resource (contacts), and scope (one page, newest first), and immediately distinguishes itself from the sibling tool search_contacts by noting it handles exact matches. This is a precise, non-tautological statement.

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 second sentence explicitly tells the agent when not to use this tool and which alternative to choose: 'For an exact email, phone, Instagram or custom-attribute match, use search_contacts instead of scanning pages.' This provides clear when/when-not guidance and names the alternative, leaving no 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?

Annotations already declare readOnlyHint=true, idempotentHint=true, and destructiveHint=false, so the safety profile is covered. The description adds meaningful behavioral context beyond the annotations: it clarifies that the notes are internal/team-visible (not customer messages), that the tool returns only one page (pagination is not automatic), and that Enterprise access is a prerequisite for the alternative message-history tool. The only minor gap is that it doesn't describe the shape of the returned page, but with no output schema and a pagination-focused description, the one-page behavior is the most important behavioral trait and it is disclosed.

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

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

Two sentences with zero waste. The first sentence states the core action and scope ('List one page of internal notes attached to a conversation'), and the second sentence adds the critical distinction from customer messages plus the sibling tool name. Every clause earns its place, and the most important scoping information is front-loaded.

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

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

For a read-only, paginated list tool with 100% schema coverage and no output schema, the description is nearly complete. It covers the resource type, the team-visible nature, the one-page behavior, and the alternative for message history. The only missing context is what the returned page contains (e.g., note fields like author, timestamp, content), but since there is no output schema and the tool is a simple list operation, this is a minor gap rather than a critical omission.

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 four parameters (conversation_id, after, before, limit) with types, constraints, and descriptions. The tool description adds no parameter-level detail beyond what the schema provides, but it does reinforce the pagination semantics by saying 'one page' and 'never fetches later pages automatically.' Baseline 3 is appropriate because the schema carries the full parameter documentation burden.

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

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

The description states a specific verb ('List'), a specific resource ('internal notes attached to a conversation'), and a scope ('one page'). It also distinguishes the tool from a sibling by clarifying these are team-visible internal notes, not customer messages, and explicitly names list_conversation_messages as the alternative for message history. This makes the tool's purpose unambiguous and differentiates it from the sibling list_conversations and get_conversation 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 explicitly says when to use this tool (to list internal team-visible notes) and when not to use it (for customer message history, use list_conversation_messages when Enterprise access is enabled). It also names the alternative tool directly. This is clear routing guidance that an agent can act on without needing to inspect sibling schemas.

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

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

Annotations already declare readOnlyHint, openWorldHint, idempotentHint, and destructiveHint=false, so the safety profile is covered. The description adds useful behavioral context beyond the annotations: results are 'metadata, not messages,' the endpoint is public, and it returns only one page. This exceeds the baseline 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?

Three short sentences, each carrying distinct information: what the tool does, what it returns, and when to use a sibling instead. No filler or redundant restatement of the schema. The most important scoping constraint is front-loaded.

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

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

For a simple paginated list tool with rich annotations and fully documented parameters, the description covers the key operational facts: page size behavior, return type (metadata not messages), filter limitations, and the contact-scoped alternative. There is no output schema, so a bit more detail about the returned pagination envelope could help, but the schema's cursor descriptions already imply it. Overall, the agent has enough to call this correctly.

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

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

Schema description coverage is 100%, and all three parameters (after, limit, before) have detailed descriptions including defaults, bounds, and cursor semantics. The tool description adds no parameter-level meaning beyond what the schema already provides, so the baseline score of 3 is appropriate.

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

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

The description states a specific verb ('List') and resource ('conversation threads across the workspace'), and immediately clarifies scope ('one page'). It also distinguishes itself from the sibling list_contact_conversations by noting the workspace-wide scope. This makes the tool's purpose unambiguous.

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

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

The description explicitly tells the agent when to use this tool versus the alternative: 'Use list_contact_conversations to scope the list to one contact.' It also states what filters are unavailable (status, inbox, text), which prevents the agent from expecting unsupported behavior. This is strong usage guidance.

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

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

The description adds behavioral context beyond the annotations by specifying that only one page is returned and what fields are included. Since readOnlyHint, idempotentHint, and destructiveHint annotations already cover safety, the description need not repeat them. No contradiction 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?

Two sentences with no fluff. The core purpose is front-loaded, and the usage hint is separated cleanly. Every word earns its place.

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

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

For a simple read-only paginated list tool, the description is sufficient: it states what the tool returns, that it is paginated to one page, and when it should be consulted. Annotations and schema cover safety and parameters, so nothing essential is missing.

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 cursor and limit parameters are already fully explained in the schema. The description does not need to add parameter details; it receives the baseline score for not duplicating schema content.

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

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

The description states a specific action ('List'), a specific resource ('custom contact attributes'), and the scope ('one page'), and also names the returned fields (IDs, types, allowed values). This clearly distinguishes the tool from the many get/list siblings in the sibling list.

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

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

The second sentence gives practical usage guidance: use this tool before searching or updating an attribute to look up its ID. It does not explicitly name alternatives or when-not-to-use conditions, but the usage context is clear and actionable.

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

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

The annotations already declare readOnly, idempotent, and non-destructive behavior. The description adds valuable behavioral details beyond that: it returns only one page, never downloads file contents, and supports pagination via after/before cursors. These traits help an agent predict exactly what will happen when invoking the tool.

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

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

The description is two sentences with no wasted words. It front-loads the core purpose, then clarifies key constraints (no download, one page, pagination). Every sentence earns its place.

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

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

For a simple read-only paginated list tool with rich annotations and fully documented parameters, the description is complete. It covers the essential behavior, pagination mechanics, and a critical non-download caveat. The absence of an output schema is acceptable here because the description already sets expectations around metadata and pagination.

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%, and the schema thoroughly documents after, limit, and before. The description reinforces the pagination semantics by mentioning after/before and one-page behavior, but it does not add substantial meaning beyond what the schema already provides. Baseline 3 is appropriate.

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

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

The description states a specific verb ('List'), a clear resource ('metadata for files already uploaded to Superchat'), and a scope ('one page'). It also differentiates itself from content-download operations by explicitly saying it does not download file contents, making it easy to distinguish from sibling tools like superchat_get_file.

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 operational guidance: use file IDs for message attachments, use after/before for pagination, and expect only one page per call. It does not explicitly name an alternative tool or state when not to use it, but the pagination and no-download context effectively conveys the intended usage.

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

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

Annotations already cover read-only, idempotent, and non-destructive behavior. The description adds useful behavioral context: pagination is manual, only one page is returned per call, and inboxes are workspace-scoped. No contradiction with annotations.

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

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

Three short sentences with no filler: purpose first, then downstream use, then pagination behavior. Every sentence earns its place.

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

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

For a simple read-only list tool with full schema coverage and rich annotations, the description covers scope, pagination, and one-page behavior. It doesn't describe the inbox object shape, but no output schema exists and the description is sufficient for 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?

Schema description coverage is 100%, so the schema already documents after, before, and limit thoroughly. The description reinforces cursor usage but adds no new parameter semantics beyond what the schema provides.

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

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

Description opens with 'List one page of inboxes that organize conversations in this workspace' – a specific verb, resource, and scope. It clearly distinguishes this paginated list tool from singular siblings like get_inbox.

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

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

It explicitly instructs using after/before cursors to continue pagination and warns that each call returns only one page. It doesn't name alternative tools like get_inbox, but the usage context is clear enough for a list endpoint.

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

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

Annotations already declare readOnlyHint, openWorldHint, idempotentHint, and destructiveHint=false, covering the safety profile. The description adds valuable behavioral detail beyond this: it explicitly states that each call returns only one page and explains how pagination works, which is not present in the annotations. It also adds domain context about label ownership. No contradictions.

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

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

The description is two short sentences, front-loaded with the core purpose, followed by a clarifying distinction and pagination guidance. Every word earns its place; there is no redundancy or filler.

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

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

Given this is a straightforward list tool with annotations covering safety and the schema fully documenting parameters, the description provides sufficient context: what it lists, the ownership distinction, and the single-page behavior. No output schema exists, so return format is not expected. It is complete for an agent to call 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?

All three parameters (after, limit, before) have descriptions in the input schema, so schema coverage is 100%. The description mentions after/before and pagination but does not add any semantic meaning beyond what the schema already provides. Per the baseline for high coverage, a score of 3 is appropriate.

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

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

The description states a specific action ('List one page of labels') on a clear resource ('labels used to organize conversations'), and immediately distinguishes them from contacts. This cleanly separates it from sibling tools like superchat_list_contact_lists and superchat_get_label, making the tool's role 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 gives implicit guidance by clarifying that labels belong to conversations, not contacts, which hints at when not to use this tool. It also explains how to use after/before for pagination. However, it does not explicitly name alternatives or state conditions for when to choose this over other list tools, leaving some inference to 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 mark the operation as read-only, idempotent, and non-destructive. The description adds useful behavior beyond that: results are limited to one page and templates expose approval status and positional variables, which matters given there is no output schema. It does not detail cursor mechanics, but the schema already documents those.

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

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

Two short sentences front-load the core action and follow with the key use case. There is no filler or repetition 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?

For a list tool with no required parameters, the description plus complete parameter schema is mostly sufficient. With no output schema, naming approval status and positional variables partially fills the return-value gap; an explicit note about pagination cursors in results would make it fully 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%, so the baseline is 3 and the description does not need to re-explain parameters. It mentions channel_id and type as filters but adds no new meaning beyond the schema.

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

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

The description opens with 'List one page of message templates', naming the action and resource precisely and adding the pagination scope. This is distinguishable from the sibling get_template and other list_* tools because it targets templates as a pageable collection.

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

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

It gives a clear intended workflow: filter by channel_id or template type, then inspect approval status and positional variables before sending. It does not explicitly name excluded cases or the get_template alternative for single-template lookup, so it falls short of 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 already declare readOnly, idempotent, openWorld, and non-destructive behavior, and the description aligns with them. It adds the important behavioral fact that pagination is manual and page-limited—'each call returns only one page'—which is not captured by the annotations alone. The note about using IDs when assigning conversations also provides practical downstream 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 three short sentences with the core operation front-loaded, followed by purpose and pagination guidance. Every sentence earns its place, and there is no repetition of schema details or filler.

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

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

For a low-complexity read-only list tool, the description covers the operation, page-limited behavior, pagination continuation, and why the IDs matter downstream. The input schema supplies parameter defaults and constraints, and the annotations cover the safety profile, so nothing essential is missing for 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?

Schema description coverage is 100%, and the after, before, and limit parameters each have detailed descriptions, including the constraint that before cannot be combined with after. The description restates the after/before pagination flow but does not add meaning beyond what the schema already provides, so the baseline of 3 is appropriate.

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

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

The description opens with a specific verb and resource: 'List one page of workspace users,' making the tool's scope immediately clear. It distinguishes itself from sibling list/get tools by naming the workspace-users resource and emphasizing pagination. The downstream purpose ('Use their IDs when assigning conversations') adds useful context without blurring the 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 gives clear pagination guidance: use after or before to continue from a previous page, and each call returns only one page. It does not explicitly name an alternative such as get_user for single-user lookups or state when not to use this tool, but the context is clear enough for correct invocation.

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

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

Annotations already declare readOnlyHint, openWorldHint, idempotentHint, and destructiveHint=false, so the safety profile is covered. The description adds useful behavioral limitations beyond annotations: it is a read-only POST, exact-match only, and cannot combine conditions or do fuzzy matching.

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

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

Two sentences, both dense with useful information. The core purpose is front-loaded, and the limitations/alternative are packed into the second sentence with no wasted words.

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

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

Given the input schema fully documents all six parameters and the annotations cover read-only behavior, the description is mostly complete. The main gap is that there is no output schema and the description does not explicitly describe the result shape or pagination return fields, but the schema context and tool name make these reasonably inferable.

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 field enums, value types, pagination cursors, limit, and identifier. The description adds the 'exact equality match' semantics and friendly field names, but it does not add significant parameter-level detail beyond the schema.

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

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

The description states a specific verb and resource: 'Find contacts with one exact equality match on email, phone, Instagram ID or a custom attribute.' It clearly defines the matching mode and scope, and the final sentence distinguishes it from list_contacts, so an agent can tell it apart from siblings.

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

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

The description explicitly says this tool does not support fuzzy name search or combining conditions, and it names list_contacts as the alternative for browsing. This is direct when-to-use and when-not-to-use guidance with a concrete alternative.

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