bird

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

The description claims the operation is 'additive,' but annotations set destructiveHint=true, which is a direct contradiction. No other behavioral context (auth, side effects) is provided, so transparency fails.

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 concise sentences that include the key behavior, a caveat about static audiences, and the API endpoint. No waste; front-loaded with the core action.

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

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

Despite good schema coverage, the description lacks information about return values or side effects, and it contradicts the destructiveHint annotation. This makes the overall picture incomplete for an agent invoking the tool.

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

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

Schema descriptions cover all 3 parameters (100%), so the description is not required to explain them. The note that 'Static audiences start empty' adds a small behavioral detail about the type parameter, but does not materially improve semantic 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 tool creates an audience (contact list) and distinguishes it from creating contacts or messages. The mention of 'additive, sends no message' uniquely identifies its purpose.

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

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

The description implies usage by specifying it's for audience creation without sending messages, but it does not explicitly state when to use this over sibling tools like bird_create_contact or when not to use it. No exclusions or alternatives are named.

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?

Description says 'additive, sends no message,' which is helpful, but it directly contradicts the annotation destructiveHint=true. The annotation signals possible destructive behavior, while 'additive' asserts no destruction occurs. Per rubric, this contradiction yields score 1.

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

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

Single-sentence description that is front-loaded with the verb and includes the endpoint; every word earns its place. Score 5.

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

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

The tool has a nested data object and no output schema, and the description doesn't explain the return value or duplicate handling beyond uniqueness. With the annotation contradiction, the description is not fully complete, though the schema covers parameters. Score 3.

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 five parameters have complete schema descriptions (coverage 100%), so the schema does the heavy lifting. The description adds only the email uniqueness note already present in the schema; no additional parameter meaning is contributed. 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 it creates a contact (CRM record) in Bird, with the specific qualifier 'additive, sends no message,' distinguishing it from get/list sibling tools and clarifying it is not a messaging operation. This is a specific verb+resource with additional 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?

Provides clear context that this tool is for adding a new contact, with the uniqueness-by-email constraint, but does not explicitly mention alternatives or when not to use (e.g., if contact exists). Since context is clear but no exclusions or alternative guidance is given, score 4.

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, so the description need not repeat that. It aligns with the annotation by saying 'Fetch' and adds the API endpoint, but does not disclose return format, error behavior, or any additional side effects. This is adequate but not rich.

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

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

The description is two short, focused sentences. The first sentence front-loads the primary purpose, and the second adds the concrete API endpoint without unnecessary elaboration.

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

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

For a simple one-parameter, read-only tool, the description is sufficient. It tells what the tool does, the API endpoint, and the required ID, while the schema and annotations cover the parameter and safety profile. No output schema exists, but 'Fetch a single audience' adequately indicates the return concept.

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

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

The input schema has 100% coverage with the parameter audience_id described as 'Audience id.' The description adds no new semantic meaning beyond restating that the lookup is by ID, so it does not exceed the baseline for high schema coverage.

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

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

The description uses a specific verb ('Fetch') and resource ('a single audience by id'), clearly distinguishing it from sibling tools like bird_list_audiences and bird_create_audience. The phrase 'by id' establishes the exact scope of 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 makes clear that this tool is for fetching one specific audience when an audience_id is available, which implies when to use it versus listing audiences. However, it does not explicitly name an alternative or state when not to use it, such as 'use bird_list_audiences to get all audiences.'

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 declare readOnlyHint=true, and the description discloses the HTTP method (GET) and endpoint, which reinforces safety. It adds the exact resource path, which is useful. However, it does not explain error behavior (e.g., 404 if not found), auth requirements, or response format. With annotations covering the safety profile, a score of 3 is appropriate.

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

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

The description is two concise sentences, including the purpose and the API endpoint. No wasted words. All information is directly useful and easy to parse.

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

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

This is a simple tool with one parameter, no output schema, and read-only annotation. The description provides the endpoint and purpose, which covers the core need. However, without an output schema, it does not mention what the response contains (e.g., contact fields), which could be a gap for agents expecting structured output. Given the low complexity, the description is almost complete.

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

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

The input schema has 100% coverage for the single parameter contact_id, with description 'Contact id.' The tool description also refers to 'by id', so the parameter's meaning is fully clear from the schema. The description adds no extra syntax or format details beyond the schema, so the baseline of 3 applies.

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

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

The description 'Fetch a single contact by id' uses a specific verb ('Fetch') and resource ('a single contact') with a clear scope ('by id'), distinguishing it from siblings like bird_list_contacts (which lists multiple) and other bird_get_* tools. The explicit API endpoint further clarifies the exact 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 clearly implies usage: when you have a contact_id and need a single contact. It provides clear context ('by id') and even specifies the API endpoint. However, it does not explicitly mention alternatives (e.g., bird_list_contacts for multiple contacts), but the singular framing makes this 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=true, and the description's 'Fetch' and 'GET /v1/email/messages/{message_id}' are consistent with a read operation. The description adds the single-resource scope and API method, but doesn't disclose additional behaviors such as error handling or response 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?

The description is one sentence, front-loaded with the action and resource, and includes the API endpoint as a helpful reference. 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?

For a simple getter with one parameter, readOnlyHint annotation, and no output schema, the description is sufficient. It scopes the operation and provides the endpoint, though it doesn't detail the return payload.

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 full coverage with a description for message_id ('Email message id.'), so the baseline is 3. The description's 'by id' reinforces the parameter but doesn't add new semantics 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 uses a specific verb ('Fetch'), specifies the resource ('a single email message'), and identifies the selection key ('by id'). It clearly distinguishes from sibling tools like bird_list_email_messages (listing) and bird_get_sms_message (different channel).

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 indicating the operation takes an id, but it does not explicitly state when to choose this over bird_list_email_messages or other getters. There is no exclusions/alternatives mentioned.

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

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

Annotations already declare readOnlyHint=true, and the description's 'Fetch' is consistent with that. The description adds the concrete API endpoint, but provides no extra behavioral details such as error cases or rate limits. This matches the baseline for a simple read with annotation coverage.

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

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

The description is a single, direct sentence that states the action, resource, and API path. Zero wasted words, perfectly 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 one parameter, a clear purpose, and readOnly annotation, the description is complete. No output schema exists, so no return-value documentation is needed.

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

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

The input schema has one parameter with 100% description coverage, so the schema already fully explains 'message_id'. The description doesn't add anything beyond the schema, which is acceptable given the high coverage 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 uses the specific verb 'Fetch' and names the resource 'single SMS message by id', which clearly distinguishes it from listing all SMS messages or fetching other message types. The API path reinforces the exact 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 phrase 'by id' implies this is for retrieving a specific message when you have its ID, which implicitly tells the agent when to use it versus list operations. It does not explicitly name alternatives or exclusions, 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 provide readOnlyHint=true, and the description's 'Fetch' and 'GET' are consistent with that. The description adds little beyond what annotations and the name convey—it mentions the API endpoint and single message scope but does not disclose error behavior, rate limits, or return format. With annotations covering safety, this addition is marginal but acceptable.

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

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

The description is a single, front-loaded sentence: 'Fetch a single WhatsApp message by id. Bird API: GET /v1/whatsapp/messages/{message_id}.' Every word earns its place, and it is not verbose or redundant.

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, read-only annotation, and no output schema, the description is sufficiently complete. It specifies the exact resource and operation, and the schema fully documents the parameter. It does not describe the response fields, but that is not critical for tool selection/invocation given the simplicity and lack of output schema. A 4 reflects very good completeness without being perfect.

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%: the only parameter message_id is described as 'WhatsApp message id.' The description's 'by id' and endpoint placeholder {message_id} adds no extra semantic meaning beyond the schema. Baseline 3 is appropriate because the schema fully documents the parameter.

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 'Fetch a single WhatsApp message by id', which is a specific verb+resource+scope. It distinguishes from siblings like bird_get_email_message (different channel), bird_get_sms_message (different channel), and bird_list_whatsapp_messages (plural 'list' vs singular 'single').

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

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

The description implies usage for a single message lookup via 'single' and 'by id', providing clear context. However, it does not explicitly mention alternatives or when not to use, such as using bird_list_whatsapp_messages for multiple messages or bird_get_email_message for email messages. Thus it falls short of a 5 but is above a 3.

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 readOnlyHint annotation already covers the read-only nature. The description adds 'cursor page' and API reference, disclosing pagination behavior. However, it does not detail response format or rate limits, but with annotation coverage the bar is lower, matching the 3-level where added value exists without being comprehensive.

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

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

The description is a single, front-loaded sentence that communicates the primary action and scope, with no redundant details. Every word earns its place.

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

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

Given the simple list operation with good annotations and full schema coverage, the description sufficiently covers core behavior. The mention of 'cursor page' aligns with pagination params, and the tool name implies the return of contacts. Although no output schema exists, the description is adequate for this low-complexity tool.

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

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

The input schema provides full descriptions (100% coverage) for all three parameters, including limit, audience_id, and starting_after. The description's 'cursor page' phrasing hints at pagination but does not add meaning beyond what the schema already documents, so baseline 3 is appropriate.

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

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

The description clearly states the action ('List') and the resource ('contacts that belong to a static audience'), distinguishing it from sibling tools like list_contacts which likely lists all contacts. Including the API endpoint reinforces the specific 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 by specifying 'a static audience', implying this tool is for audience-scoped contact retrieval. It does not explicitly mention alternatives or exclusions, but the context is sufficiently distinct.

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

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

Annotations already declare readOnlyHint=true, and the description adds behavioral context: 'newest first' and 'cursor page' reveal ordering and pagination behavior, plus the API endpoint reference. This goes beyond what annotations provide, though it doesn't detail return formatting.

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 front-loads the action and resource with key behavioral details, the second provides the API endpoint. No fluff or redundancy.

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

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

Given the simple listing purpose and the rich schema (including references to `next_cursor`), the description plus schema provide sufficient context. It mentions endpoint, ordering, and pagination, though it doesn't explicitly describe the response shape; however, this is partially covered by schema references.

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

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

Schema description coverage is 100%, with 'limit' and 'starting_after' fully described in the schema. The description doesn't add parameter-specific semantics beyond the schema, so the baseline of 3 applies.

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

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

The description uses a specific verb 'List' with a clear resource 'audiences (contact lists)' and scope 'in the workspace'. It also specifies 'newest first, as a cursor page', which distinguishes it from sibling tools like bird_create_audience and bird_get_audience.

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 when to use this tool (listing all audiences) and provides context about ordering and pagination. It doesn't explicitly name alternatives or exclusion criteria, but sibling tools are obviously different in purpose (create/get), making the usage context 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, and the description adds context by specifying 'custom contact-property definitions' and workspace scope, plus the API endpoint. However, it does not disclose pagination behavior or return format beyond what the schema implies, so it provides only modest additional 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 two sentences, front-loaded with the core purpose, and contains no fluff. It efficiently states what the tool does and provides the API endpoint for reference.

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 two optional parameters and no output schema, the description adequately covers the intent and scope. It could mention that results are paginated or list field details, but the schema already covers this, and the description's brevity is acceptable for the tool's simplicity.

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 (limit, starting_after) have clear descriptions in the schema. The tool description does not add any parameter-specific semantics, which is acceptable given the baseline of 3 when schemas fully document parameters.

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 lists custom contact-property definitions (schema) for the workspace, using a specific verb and resource. It distinguishes itself from sibling list tools by specifying 'contact-property definitions' rather than contacts or messages.

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 naming the resource and API endpoint, but gives no explicit guidance on when to use this tool vs alternatives or prerequisites. There are no direct sibling tools for contact properties, so the lack of exclusions is acceptable, but it does not explain use cases like retrieving available properties before creating contacts.

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, so the description adds valuable context by disclosing 'newest first' ordering and 'cursor page' pagination. This goes beyond the annotation without contradicting it.

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 brief sentences, front-loaded with the action and resource, followed by the API endpoint. Every word earns its place, and there is 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?

For a low-complexity tool with no output schema, the description covers the essential aspects: what it does, scope, ordering, pagination, and endpoint. It could mention return fields, but that is not critical given the cursor-page design and provided schema descriptions.

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?

Input schema covers both parameters (limit, starting_after) with descriptions, so baseline is 3. The description adds 'cursor page' context that aligns with starting_after, but doesn't formally explain each parameter beyond what the schema already provides.

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

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

The description clearly states the verb 'List', the resource 'contacts (CRM records)', scope 'in the workspace', ordering 'newest first', and pagination style 'as a cursor page'. This distinguishes it from siblings like bird_create_contact, bird_get_contact, and bird_list_audience_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 implies usage for listing workspace-level contacts, but does not explicitly mention alternatives or exclusions. Sibling bird_list_audience_contacts exists, but no guidance is given about when to use one over the other.

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 readOnlyHint=true already disclosed in annotations, the description adds useful behavioral context by specifying 'sent from the workspace,' 'newest first,' and 'cursor page' pagination. It does not describe error handling or rate limits, but the added details go beyond the annotation baseline.

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

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

The description is a single, front-loaded sentence that efficiently conveys the core purpose, ordering, pagination mode, and API endpoint. Every phrase adds value with no redundant or filler content.

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

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

For a simple list tool with two optional parameters and no output schema, the description sufficiently covers what the tool does and key behaviors (order, pagination, workspace scope). It could mention the exact shape of the response page, but the schema's reference to 'next_cursor' and the term 'cursor page' provide adequate context for 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%; both parameters (limit and starting_after) are fully described in the schema. The tool description does not add any additional parameter-level explanation, so it remains at the baseline for high schema coverage.

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

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

The description clearly states the tool lists email messages sent from the workspace, with specific details like newest-first ordering and cursor pagination. This distinguishes it from sibling tools such as list_sms_messages or list_whatsapp_messages, which handle different message 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 implied usage context by stating exactly what the tool does (list email messages), but it does not explicitly mention alternatives or when to prefer this tool over related ones like get_email_message for single messages. No exclusions are noted, so guidance is limited to the 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=true, so the agent knows this is a safe read. The description adds useful behavioral context: it lists both inbound and outbound messages, orders newest first, and uses cursor pagination, which goes beyond the annotation and helps set expectations.

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, information-dense sentence. It front-loads the action and resource, includes ordering and pagination behavior, and appends the API endpoint. 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?

For a simple list tool with two well-documented parameters, a read-only annotation, and no output schema, the description covers the essential aspects: what is listed, scope, ordering, pagination mechanism, and API reference. It is sufficiently complete for an agent to select and invoke correctly.

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

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

Schema description coverage is 100%, with clear descriptions for both 'limit' and 'starting_after'. The description's mention of 'cursor page' aligns with the pagination parameters but adds little meaning beyond the schema, 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 the specific verb 'List' with a clear resource ('SMS messages'), scope ('for the workspace'), ordering ('newest first'), and pagination style ('cursor page'). It also notes both inbound and outbound, distinguishing it from single-message tools like bird_get_sms_message and other message-type listers.

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 this is the tool for paginated listing of SMS messages in the workspace, giving context like newest first and cursor-based paging. It does not explicitly name alternatives or exclusions, but the resource specificity makes the intended use clear relative to sibling tools.

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

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

Annotations already declare readOnlyHint=true, so the agent knows this is a safe read. The description adds context that the list includes both Bird built-ins and the user's own templates, and references the API endpoint. This enriches understanding beyond the annotation without contradicting it.

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 plus an API endpoint reference, front-loaded with the verb and resource. It contains no redundant information and is appropriately compact.

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

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

For a simple list operation with zero required parameters and full schema coverage, the description is sufficient. The lack of an output schema is acceptable because list tools are generally understood to return arrays of the resource, and the readOnlyHint annotation covers safety.

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

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

The input schema provides complete descriptions for all three parameters (scope, category, language), with coverage at 100%. The description adds no additional parameter semantics beyond what the schema already offers, so baseline 3 applies.

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

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

The description clearly states the tool lists SMS templates available to the workspace, using the verb 'List' and specifying the resource ('SMS templates'). It distinguishes from sibling tools like bird_list_whatsapp_templates by explicitly naming the SMS channel and including the API endpoint.

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 that this tool lists SMS templates with workspace scope, but does not explicitly mention when to use this over related tools like bird_list_sms_messages or bird_list_whatsapp_templates. Since the resource is unambiguous, it earns a 4 for clear context without exclusions.

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

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

Annotations already declare readOnlyHint=true, and the description adds behavioral context: it lists both inbound and outbound, orders by newest first, and uses cursor-based pagination. Also includes the Bird API endpoint. This goes beyond the annotation and helps the agent anticipate pagination behavior.

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

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

Two concise sentences. The first packs the key information (action, scope, direction, ordering, pagination type), and the second provides the API endpoint. No wasted words or redundancy with 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 simple read-only list tool with 2 optional params and no output schema, the description covers purpose, scope, ordering, and pagination. It does not explicitly describe the response shape, but 'cursor page' and the schema's reference to `next_cursor` imply a standard page structure. Overall, sufficiently complete given low complexity.

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

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

Schema coverage is 100%: both parameters (limit, starting_after) have descriptions in the input schema. The description does not add parameter-specific details beyond what the schema already provides, so 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 states a specific action: 'List WhatsApp messages (inbound + outbound) for the workspace, newest first, as a cursor page.' It clearly names the resource (WhatsApp messages), scope (workspace), direction (inbound+outbound), and ordering (newest first), distinguishing it from sibling get/list tools like bird_get_whatsapp_message and bird_list_sms_messages.

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

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

The description implies usage for listing workspace WhatsApp messages with pagination. It does not explicitly state when not to use it or name alternatives, but the clear resource and 'workspace' scope provide enough context for an agent to select it over other list or 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?

Annotations already declare readOnlyHint=true, and the description adds the workspace scope and API endpoint reference. It does not contradict annotations, but lacks additional behavioral details like pagination or response 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?

A single, front-loaded sentence provides the essential information, followed by an optional API reference. Every word earns its place with no 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 simple, parameterless list tool with a read-only annotation and no output schema, the description is sufficient. It names the resource and scope, though it could optionally mention pagination or response shape.

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 zero parameters, the baseline is 4. The description correctly mentions no parameters are needed, and there is no additional parameter context required.

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

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

The description uses a specific verb ('List') and identifies the exact resource ('WhatsApp message templates') plus scope ('available to the workspace'). It clearly distinguishes from sibling tools like bird_list_whatsapp_messages and bird_list_sms_templates.

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 use when you need to view WhatsApp templates, but does not explicitly state when to prefer this over alternatives or provide exclusion criteria. Context is clear but no alternative guidance is given.

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