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

With no annotations provided, the description carries the behavioral burden and explicitly marks the operation as 'Write' with downstream consequences: contact segmentation changes and possible automation triggers. It does not cover all edge cases such as duplicate tags or idempotency, but the core mutation and side-effect behavior 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 short sentences deliver the action, the source of each parameter, and the behavioral warning with no filler or redundancy. The 'Write:' label efficiently marks the mutation aspect.

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 low complexity, the description covers what the tool does, how to populate both required parameters, and what side effects to expect. It does not describe return values or duplicate-handling, but these are not critical for an agent to select and invoke this simple write operation.

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

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

Schema descriptions cover 0% of parameters, so this text compensates by explaining where each value comes from: user_ns from find_contact and tag_name from list_tags. This is actionable and adds real meaning beyond the raw property names, though it stops short of defining the value semantics in depth.

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 object, 'Add a tag to one contact,' making the operation and singular scope unmistakable. It naturally distinguishes the tool from siblings such as remove_contact_tag and list_tags.

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 clear invocation guidance by telling the agent to source user_ns from find_contact and tag_name from list_tags. It does not explicitly name alternatives or when-not-to-use conditions, but the singular scope and add/remove sibling context make the intended usage easy to infer.

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

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

With no annotations, the description carries the full burden of behavioral disclosure. It explicitly states 'Write: reroutes the conversation', indicating it's a mutating operation with a clear side effect. However, it does not describe reversibility, permissions, interactions with the bot (e.g., pausing), or potential failure conditions. It goes beyond a tautology but remains minimal.

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

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

The description is extremely concise—three short sentences that front-load the purpose, then provide essential sourcing and effect information. No filler or redundancy; every phrase 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 two-parameter tool with no output schema, the description covers the core inputs and the primary effect. It does not mention edge cases (e.g., already-assigned contacts, bot state) or prerequisites besides sourcing parameters, but these are likely covered by sibling context and the simplicity of the operation. It's slightly lean but adequate for an agent to make an informed call.

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 0%, so the description must compensate. It does so by explaining that `user_ns` comes from `find_contact` and `agent_id` from `list_agents`, which provides provenance and likely type context. While it doesn't fully redefine each parameter, the mapping to source tools adds meaningful semantic value beyond the bare type 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 uses a specific verb ('assign') and clearly states the resource ('a contact's chat') and recipient ('human agent'). This distinguishes it from siblings like assign_agent_group (assign to a group) and unassign_agent (remove assignment). The phrase 'Write: reroutes the conversation' further clarifies the action's effect.

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 explicit guidance on sourcing parameters: `user_ns` from `find_contact` and `agent_id` from `list_agents`. This tells the agent exactly how to obtain inputs. However, it doesn't explicitly exclude alternatives like `assign_agent_group` or mention when not to use this tool. The condition 'to a human agent' implies a distinction but lacks explicit 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?

Since no annotations are provided, the description must disclose behavioral traits. It states 'Write: reroutes the conversation,' which clearly indicates a mutating operation and its primary effect. However, it does not detail side effects such as whether the existing assignment is replaced, what happens to the assigned human agent, or any permission requirements. Basic disclosure is present, but depth 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 a single sentence followed by a concise provenance note. It is front-loaded with the action, uses backticks for parameter sources, and contains no fluff. Every element earns its place, 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 tool with only two parameters, no output schema, and no annotations, the description covers the essential aspects: what it does, how to obtain the parameters, and the effect (reroutes the conversation). It does not mention error conditions or return values, but for such a focused operation, the provided details are reasonably 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?

With schema description coverage at 0%, the description compensates well by explaining that user_ns comes from find_contact and agent_group_id from list_agent_groups. This gives clear provenance and usage guidance for both parameters, which is far more valuable than the raw schema alone. It does not describe formats or constraints, but the sourcing hints are highly actionable.

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: 'Assign a contact's chat to an agent group.' This clearly distinguishes it from sibling tools like assign_agent (which assigns to a single agent) and move_chat (which moves conversations). The verb 'assign' and resource 'agent group' are unambiguous and the scope is well-defined.

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 provenance for both parameters ('user_ns from find_contact; agent_group_id from list_agent_groups'), which is helpful context. However, it does not explicitly state when to use this tool over the alternative assign_agent, nor does it mention any exclusions or preconditions beyond the rerouting effect. The 'Write: reroutes the conversation' hint conveys the effect but not the decision 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?

With no annotations available, the description carries the full burden and does well: it labels the operation read-only, discloses phone normalization, and explains the ambiguous-match behavior of returning all matches while leaving `user_ns` None. It could add no-match or error behavior, but the key behavioral traits are covered.

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 tightly packed sentences lead with the core purpose and immediately follow with the only usage constraint and the notable edge-case behavior. Every sentence adds value and none are redundant with the schema.

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

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

For a simple two-parameter lookup with no output schema or annotations, the description is nearly complete: it defines inputs, constraints, normalization, read-only status, and ambiguous-match handling. It stops short of specifying no-match behavior or exact response shape, but those gaps are minor 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?

Schema description coverage is 0%, and the description fully compensates by explaining both parameters, their relationship (exactly one), phone normalization, and what `user_id` means with a concrete example. An agent can construct correct arguments without needing extra schema documentation.

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

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

The description clearly states a specific action ('Resolve a user_ns') and the two input keys that drive the lookup, making the tool's purpose obvious. It does not explicitly name a sibling to distinguish against, but the resolution-focused wording separates it from related contact 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 explicit usage guidance: pass exactly one of `phone` or `user_id`, and it even explains the Ecuadorian normalization and WhatsApp `wa_id` example. It does not discuss when to prefer this over `get_contact` or `list_contacts`, but it provides clear enough context for the intended use.

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

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

With no annotations provided, the description carries the full burden of behavioral disclosure. It explicitly states 'Read-only,' which is a critical safety trait. It also mentions 'full profile,' implying a comprehensive return. However, it doesn't specify behavior for non-existent contacts or error handling. Given the simplicity of a get operation, this is adequate but not exhaustive.

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 with zero filler. It front-loads the core action and immediately follows with the parameter source. Every word serves a purpose, 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 single-parameter read operation with no output schema, the description is nearly complete. It specifies the input, its provenance, and the read-only nature. It doesn't elaborate on return fields, but 'full profile' is reasonably self-explanatory. Gaps like error responses are minor for this type of tool.

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

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

The schema provides only the type and required status for user_ns. The description adds essential semantic meaning: '`user_ns` from `find_contact` or `list_contacts`.' This tells the agent exactly how to obtain a valid value, compensating for the 0% schema description coverage. Without this, the parameter would be ambiguous.

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 action: 'Return the full profile for one contact.' This specifies a single resource and distinguishes it from sibling tools like list_contacts (which lists multiple) and find_contact (which searches). The explicit mention of 'one contact' and 'full profile' precisely defines the scope.

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

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

The description provides clear guidance on where the required parameter comes from: '`user_ns` from `find_contact` or `list_contacts`.' This tells the agent when to use this tool (after obtaining a user_ns) and implies alternatives for finding contacts. It doesn't explicitly exclude other uses, but the context is sufficient. The read-only note also indicates safe 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?

No annotations are provided, so the description carries the burden. It discloses read-only behavior, which is the key side-effect signal, but does not mention error behavior, response shape, or any access prerequisites. This is adequate for a simple read tool but not richly transparent.

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 clauses in two sentences, with the core purpose first and no filler. Every phrase earns its place: what it returns, how to get the input, and its read-only nature.

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

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

For a one-parameter read operation with no output schema, the description covers the essential concerns: what is returned, where the ID comes from, and that it is safe. It could specify the return shape more concretely, but the tool is simple enough that 'full detail' is reasonably clear.

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

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

Schema description coverage is 0%, so the description must compensate. It adds meaningful provenance for the sole parameter ('order_id from list_orders'), telling the agent exactly how to obtain a valid value. The integer type is left to the schema, but the source guidance is the more important semantic.

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 verb and resource: returns full detail for one order, clearly distinct from list_orders which lists orders. No ambiguity with sibling tools because it names the exact entity and 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?

Explicitly tells the agent where to obtain order_id (from list_orders), establishing a clear workflow. It does not name alternatives or exclusions, but no competing order-detail sibling exists, so the guidance is sufficient.

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

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

No annotations are provided, so the description carries the full burden. It explicitly states 'Read-only' and mentions pagination, which are positive behavioral disclosures. However, it does not describe return format, error handling, rate limits, or auth requirements. This is a modest level of transparency for a read operation with no annotations.

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

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

Two sentences with minimal waste. The core action and key parameters are front-loaded, and the origin of IDs is clearly stated in the second 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 list tool with no output schema, the description covers the essential inputs and their provenance. It states pagination and read-only nature. It could elaborate on response format or pagination details, but the tool's simplicity and the provision of ID sources make it sufficiently complete for an agent to invoke it correctly.

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

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

With 0% schema description coverage, the description compensates well by explaining the purpose of all parameters: `list_id` (source: list_ticket_lists), `user_ns` (filter, source: find_contact), `title` (filter), and `page` (implicitly via 'paginated'). It adds meaning beyond field names, though it does not specify exact matching semantics or value formats.

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

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

The description uses a specific verb ('List') and resource ('items in one ticket list'), and clarifies it is paginated. It also indicates filter options and provides provenance for key IDs, distinguishing it from sibling tools like list_ticket_lists (which lists lists) and get_order (which retrieves a single order). This is a clear, unambiguous 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 stating that `list_id` comes from `list_ticket_lists` and `user_ns` comes from `find_contact`, giving context on how to obtain parameters. However, it does not explicitly state when to use this tool vs. alternatives or provide exclusions. The guidance is adequate but not explicit about alternative selection.

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

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

The description includes 'Read-only', which is a key behavioral trait, and mentions the purpose of the returned `agent_group_id`. However, with no annotations provided, the description carries the full burden and does not disclose other potential behaviors like pagination, ordering, or error conditions. The read-only disclosure and output purpose provide moderate transparency, but not complete.

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 redundancy. It front-loads the primary action and filter, then adds the key output detail. 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 list tool with one optional parameter and read-only behavior, the description covers the essentials: what it does, the filter, and the important output (agent_group_id). It does not mention pagination or sorting, which could be relevant for large lists, but given the context and lack of output schema, this is likely sufficient.

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

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

The schema has one optional parameter, `name`, with no description. The tool description explains it as an optional filter, which adds meaning beyond the schema. This effectively compensates for the 0% schema coverage, though it could be more specific about the filtering behavior (e.g., exact match vs substring).

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 ('agent groups'), and clarifies the purpose by linking to `assign_agent_group`. It distinguishes itself from sibling list tools by specifying that it provides `agent_group_id`, making its role clear without needing to inspect 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 mentions 'optionally filtered by name' and that it provides `agent_group_id` for `assign_agent_group`, giving clear context on when to use it (when you need group IDs for assignment). It does not explicitly name alternates, but the sibling list tools are distinct enough, and this tool is the only one for agent groups.

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

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

With no annotations provided, the description explicitly states 'Read-only', which is a key behavioral disclosure. It also communicates that it returns agent_id for downstream assignment, though it does not detail pagination or exact filtering behavior.

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

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

The description is three short, purposeful clauses with no filler. It front-loads the action and adds read-only and downstream-use information 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 two-parameter list tool with no output schema, the description covers the main invocation details: resource, optional filters, read-only safety, and the expected agent_id. Minor details like response shape or pagination are not stated, but they are not critical for correct selection.

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

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

Schema description coverage is 0%, so the description must compensate. 'Optionally filtered by name/role' adds meaning to the two params, but matching semantics and format are left unspecified.

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 ('team agents') and clarifies the optional filters by name/role. It also distinguishes the tool's output by noting it provides agent_id for assign_agent, which separates it from generic list and read 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 line 'Provides agent_id for assign_agent' gives a clear downstream use case, telling an agent when this tool is needed. It does not explicitly enumerate alternatives or when-not cases, but the context is sufficient for selection.

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

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

With no annotations provided, the description carries the burden of behavioral disclosure. It explicitly labels the operation as 'Read-only' and notes the optional filtering behavior. It does not detail output shape or pagination, but for a simple read-only list operation this is solid 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?

Two concise sentences with no filler. The main action is front-loaded, and the downstream use case plus read-only status are stated in one short second sentence.

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-optional-parameter, read-only list tool, the description is mostly complete. It covers the operation, filter behavior, read-only safety, and how to use the results with set_contact_field. The lack of an explicit output schema is a minor gap because the description implies the relevant field_name values are returned.

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

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

Schema description coverage is 0%, so the description must compensate. It does explain that `name` optionally filters results, which is the core semantic. However, it does not specify whether matching is exact, partial, or case-sensitive, leaving some ambiguity.

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 the custom contact-field definitions' with an optional name filter. This clearly distinguishes it from siblings like list_contacts or list_tags, which operate on 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 when to use this tool: 'Use to get exact field_name values for set_contact_field.' This makes the intended scenario clear, though it does not mention when not to use it or name alternative 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?

Without annotations, the description carries the full burden. It does disclose two behavioral traits: read-only and paginated. However, it leaves out how multiple filters combine (AND vs OR), whether matching is exact or partial, and what the response shape looks like, especially given there is no output schema.

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

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

The description is a single front-loaded sentence with no filler. It states the core purpose and searchable fields first, then adds the cross-tool dependency and read-only flag. 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 six-parameter read-only search with no output schema, the description provides essential details: search criteria, pagination, read-only nature, and the tag_ns source. However, it omits filter combination behavior, return value format, and any guidance on when to choose this over find_contact or get_contact, leaving some important gaps.

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

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

Schema description coverage is 0%, so the description must compensate. It adds meaning by listing the searchable fields and explicitly noting that tag_ns comes from list_tags. But it does not explain page/limit semantics, filter interactions, or the meaning of null values.

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

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

The description clearly identifies a specific verb ('Search'), a resource ('contacts'), and the searchable attributes (phone, name, email, tag_ns). It is clear and unambiguous, but it does not explicitly distinguish itself from sibling tools like find_contact or get_contact, so it misses the top score.

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

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

There is no guidance on when to use this tool versus alternatives such as find_contact or get_contact. The only usage hint is that tag_ns comes from list_tags, which is a prerequisite rather than a decision rule.

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

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

With no annotations provided, the description carries the behavioral disclosure burden. It explicitly states 'Read-only' and limits the scope to 'published sub-flows', which usefully signals what the tool does and does not expose. It does not describe pagination or output structure, but for a simple list operation this is adequate.

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 deliver the core purpose, the filter option, and the key downstream use case. The most important information is front-loaded, and there is no filler or repetition.

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 tool with one optional parameter and no output schema, the description is complete enough: it says what is listed, how results can be filtered, what identifier to extract, and that it is read-only. An agent can correctly select and invoke this tool without further documentation.

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 has 0% description coverage and only one optional `name` parameter. The description adds that this parameter filters results by name, which is useful, but it does not clarify whether matching is exact, partial, or case-sensitive. The added meaning is modest but not fully compensating for the schema gap.

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

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

The description clearly states the verb and resource: 'List published sub-flows' with an optional name filter. It also distinguishes this tool from siblings by noting it provides the exact `flow_name` needed for `trigger_flow`, which is a sibling tool in the same 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 description gives clear context: use this tool to retrieve a valid `flow_name` for `trigger_flow`. It does not explicitly state exclusions or when not to use it, but the intended workflow is evident from the mention of `trigger_flow`.

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

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

With no annotations, the description carries the burden and does disclose read-only behavior and pagination, which is valuable. However, it leaves ambiguity about whether user_ns is required, what the full unscoped list returns, and what pagination metadata or response shape looks like.

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 tight sentence with no filler, front-loading the core verb, resource, and the most important qualifiers: paginated, user_ns scoping, and read-only. Every phrase 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 list tool with three optional parameters, the description covers invocation, scoping, and safety. The lack of an output schema means return details are only implied, and it doesn't mention behavior when user_ns is omitted, but these are relatively minor gaps.

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

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

Schema description coverage is 0%, so the description must compensate. It does: 'paginated' gives meaning to page and limit, and user_ns is explicitly tied to find_contact and scoping. The schema already provides defaults, so the remaining mechanics are adequately covered.

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 operation (list), the resource (shop orders), and key behaviors (paginated, optional scoping by user_ns). It distinguishes well from the sibling get_order, which retrieves a single order.

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 explicit context on when to pass user_ns — from find_contact — to scope orders to one contact, and the pagination note implies a listing use case. It does not explicitly contrast with get_order or state when not to use it, so it stops short of full 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?

With no annotations present, the description carries the behavioral disclosure burden. It explicitly states 'Read-only' and describes the key output ('Provides tag_ns and exact tag names'), which is meaningful behavioral information beyond the schema. It does not mention pagination or error behavior, but those are less critical for a simple read-only list.

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 with no filler. It front-loads the main action and resource, then adds the optional filter and relevant downstream usage in a compact way.

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 one optional parameter, the description is sufficient: it covers what is listed, the optional filter, the read-only nature, and the intended downstream use. It omits a formal output schema description, but the statement about providing tag_ns and exact tag names covers the key returned information.

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

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

The schema has 0% description coverage for the single parameter, and the description says 'optionally filtered by name'. This adds some meaning by clarifying that `name` is a filter, but it does not explain matching behavior, case sensitivity, or format expectations.

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 and resource: 'List the account's tags'. It also notes the optional name filter and clarifies the output purpose ('Provides tag_ns and exact tag names for the tag/broadcast tools'), making the tool's role clear and distinct from sibling contact/agent 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: to retrieve tag namespace and exact tag names needed for tag/broadcast operations. It does not explicitly name alternatives or state when not to use it, but the downstream tool references provide enough 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?

With no annotations, the description carries full burden and explicitly adds 'Read-only' and notes the output provides list_id. It stops short of describing pagination, ordering, or return fields beyond list_id, but for a simple list operation this is reasonably transparent.

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 tightly packed sentences with no filler. The core action and key output are front-loaded, and the read-only note is appended 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 one-parameter, read-only listing tool, the description covers purpose, optional filtering, output purpose, and safety. Lacking an output schema, it could name the full response shape, but the essential information for invocation is present.

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 for the only parameter is 0%, so the description must compensate. It says name is an optional filter, which adds meaning the schema lacks, but it does not clarify match semantics (exact vs partial, case sensitivity).

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 states a specific verb and resource ('List ticket lists / boards') and immediately distinguishes its role by noting it provides list_id for get_ticket_list_items. This clearly separates it from contact/order/flow tools 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 description implies the primary use case: call this before get_ticket_list_items to obtain list_id. It does not explicitly discuss when not to use it or compare with other list 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?

No annotations are provided, so the description carries the burden. It explicitly states 'Read-only', which is important safety-relevant behavior, and it discloses the key output fields and the optional name filter. It doesn't cover pagination or exact-match semantics, but those are minor for a simple read-only list 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?

The description is compact and well-structured: it says what the tool does, mentions the filter, lists key outputs, and adds the read-only note. Every sentence earns its place with no filler.

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

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

For a simple list tool with one optional parameter and no output schema, the description covers the operation, filter, return fields, and safety profile. It doesn't describe the exact response shape or pagination, but the provided information is sufficient for an agent to call it and use the results with the template tools.

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 0%, so the description must compensate. It adds meaning by explaining that 'name' is an optional filter and that the tool returns fields needed for template tools. It could specify whether matching is partial or exact, but the essential parameter behavior is clear.

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'), a precise resource ('approved WhatsApp message templates'), and an optional filter ('by name'). It also explains what the result provides (namespace, name, lang, params), which clearly distinguishes this from sibling tools like send_whatsapp_template and list_flows.

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: this tool lists approved templates and supplies the fields needed by the template tools. It doesn't explicitly name alternatives or say 'use this before send_whatsapp_template', but the purpose 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?

No annotations are provided, so the description carries the full behavioral disclosure burden. It does disclose that the operation is a write and that it makes the chat visible to agents in the Chatea Pro inbox, which is helpful. However, it omits details about permissions, reversibility, and any response or side effects beyond the visibility statement.

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 compact sentences with no filler. The core operation and status values are front-loaded, and each remaining detail (`user_ns` source and inbox visibility) 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 two-parameter write operation, the description covers the necessary invocation details: the statuses allowed, the source of the `user_ns` parameter, and the resulting visibility. It does not describe return values or failure modes, but no output schema exists and the operation is straightforward enough that the given context is largely sufficient.

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

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

Schema description coverage is 0%, so the description must compensate. It does so by enumerating the allowed values for `status` and by telling the agent that `user_ns` comes from `find_contact`, adding meaning that the bare input schema lacks. It stops short of explaining the nuanced meaning of each status, but the essential semantics are present.

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 ('Move a contact's chat') and explicitly enumerates the allowed target states (`open`, `pending`, `spam`, `done`). It clearly identifies the resource being affected and leaves little ambiguity about what the tool does.

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

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

The description provides useful context such as `user_ns` coming from `find_contact` and the effect of the write, but it does not explicitly state when this tool should be used instead of a sibling tool or when it should be avoided. Usage intent is implied rather than directly specified.

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

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

With no annotations, the description carries the full burden. It states the main effect — 'automations stop replying to this contact' — and the positivity constraint on `minutes`. It does not mention reversibility or repeated-call behavior, but the core mutation 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?

One concise sentence plus a short behavioral note; no filler. The action, scope, and constraints are all 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 2-parameter tool with no output schema and no annotations, it says enough: what it does, what each parameter means, and the observable result. It could add a mention of resume_bot for a fully round-tripped picture, but 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 0%, so the description must compensate. It clarifies that `minutes` must be positive and that `user_ns` should come from `find_contact`, adding meaning beyond the raw 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 ('Pause') with a clear resource ('the bot'), scopes it to one contact, and bakes in the key parameter `minutes`. This cleanly separates it from sibling tools like resume_bot and send_text.

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?

Tells the agent exactly when to use it: to pause a bot for a single contact with a positive number of minutes. It also tells where `user_ns` comes from (`find_contact`), though it doesn't explicitly name resume_bot as the reversal 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?

With no annotations provided, the description carries the behavioral disclosure burden. It explicitly says 'Write: changes contact segmentation,' which flags a mutating side effect and its business consequence. However, it does not disclose error behavior, idempotency, or what happens if the tag does not exist, leaving some behavioral ambiguity.

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, purposeful segments: what the tool does, where parameters come from, and the side-effect warning. There is no filler, and the most important information is front-loaded.

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

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

This is a simple two-parameter mutation with no output schema and no annotations. The description covers the purpose, parameter provenance, and behavioral impact, so an agent has enough to invoke it correctly. Minor gaps like missing error cases are acceptable for a tool of this 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 0%, so the description must compensate. It does by explaining exactly where to get `user_ns` and `tag_name`, tying each parameter to another tool's output. This adds meaningful provenance beyond the schema, though it does not describe format or constraints.

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

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

The description opens with a specific verb and resource: 'Remove a tag from one contact.' This clearly identifies the operation and its scope, and the verb 'remove' distinguishes it from sibling add_contact_tag. The one-contact constraint adds precision beyond just the tool 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?

The description gives clear contextual guidance by telling the agent where to source each parameter: `user_ns` from `find_contact` and `tag_name` from `list_tags`. It does not explicitly enumerate when not to use it or mention alternatives such as add_contact_tag, but the usage context is clear enough for selecting this tool.

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

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

No annotations are provided, so the description carries the full behavioral disclosure burden. It clearly states the mutation effect ('Write: automations start replying again.') and implies that the bot was previously paused. It does not discuss edge cases like idempotency or behavior if the bot is already resumed, but for a simple state-change tool this is sufficient.

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 no filler. The core purpose and prerequisite are front-loaded, and the effect is stated in a compact, scannable way.

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 one-parameter tool with no output schema and no annotations, the description covers purpose, precondition, parameter provenance, and behavioral effect. It does not mention errors or confirmation behavior, but nothing essential for invoking the tool 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?

The input schema only provides `user_ns` as a required string with no description, so schema coverage is 0%. The description compensates by identifying `user_ns` as coming from `find_contact`, giving the agent a concrete source for the value. It does not specify format or examples, but with a single parameter this is a meaningful improvement over the schema alone.

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 ('Resume') with a clear resource ('the bot') and scope ('for one contact'), and explicitly references the complementary action `pause_bot`. It is immediately distinguishable from the sibling tools like pause_bot and find_contact.

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 the correct timing ('after `pause_bot`') and tells the agent exactly where to obtain the required `user_ns` ('from `find_contact`'). This gives clear operational guidance for when and how to use the tool.

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

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

With no annotations provided, the description carries the full burden of behavioral disclosure. It clearly states this is a write operation, is irreversible, delivers a real WhatsApp message, and is restricted to the 24h window. This is strong, though it does not mention return values or error 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?

Every sentence earns its place: the action, the parameter source, the side effect, irreversibility, and the time window. It is compact, front-loaded, and free of filler.

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

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

For a simple two-parameter send tool with no output schema, the description covers the core operational facts: what to send, to whom, the real-world consequence, and the usage restriction. It could add error handling or response information, but those are not critical for basic 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 0%, so the description must compensate. It adds meaning for `user_ns` by pointing to `find_contact` as the source, and for `content` by framing it as free-text. The parameter semantics are sufficiently clarified for an agent to call the tool correctly.

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 verb and resource: 'Send a free-text message to one contact.' This clearly distinguishes it from sibling tools like send_whatsapp_template and trigger_flow, which send templates or trigger flows. The source hint for `user_ns` adds practical clarity.

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 for use: this is a real WhatsApp message and only works inside the 24h customer-service window. It does not explicitly name alternatives or say when not to use it, but the conditions and constraints are clearly implied.

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

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

With no annotations provided, the description carries the behavioral disclosure burden. It explicitly warns: 'Write: irreversible; delivers a real WhatsApp message to the customer,' which is a strong, actionable warning about side effects. It does not mention failure modes, rate limits, or whether a request can be duplicated, but the core irreversible write behavior is clearly 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?

Three short sentences, each earning its place: the first states the action, the second provides parameter sourcing, and the third warns about irreversibility. The description is front-loaded with purpose and avoids 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 5-parameter mutation tool with no annotations and no output schema, the description covers parameter provenance and irreversible side effects, which are the most important operational facts. It does not address what success or failure responses look like, which would be helpful but is not essential for invoking 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 0%, so the description must compensate for the schema's bare titles. It does so by mapping every parameter to its source tool, grouping namespace/name/lang/params from list_whatsapp_templates and user_ns from find_contact. This gives the agent practical provenance but does not detail the exact shape or format of params beyond what the schema shows.

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 and resource: 'Send an approved WhatsApp template to one contact.' It clearly differentiates from siblings like send_text and trigger_flow by specifying a template-based message rather than free text or flow execution.

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 sourcing context: 'user_ns from find_contact; namespace/name/lang/params from list_whatsapp_templates,' which tells the agent where to obtain each parameter. It lacks explicit when-to-use versus alternatives like send_text, but the template-specific purpose and parameter provenance make the intended context clear.

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

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

With no annotations provided, the description carries the behavioral disclosure burden. It explicitly says 'Write: overwrites the stored value,' which tells the agent this is a mutating operation and that the prior value is replaced. It does not cover permissions or error behavior, but it discloses the most important side effect.

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 deliberately compact: one sentence for the action, one for parameter sources, and one for the write behavior. Every clause earns its place and the most important information is front-loaded.

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

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

For a three-string-parameter setter with no nested objects and no output schema, this description provides the operation, parameter sourcing, and mutation semantics. It is adequate for an agent to invoke correctly, though it leaves success/error behavior and permission requirements unspecified.

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 0%, so the description must compensate. It usefully identifies the provenance of two otherwise bare string parameters ('user_ns from find_contact', 'field_name from list_contact_fields') and the overwrite behavior implies that 'value' is the new field value. This adds real meaning beyond the minimal 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 a specific verb ('Set') and resource ('custom field on one contact'), making the operation immediately clear. It does not explicitly compare against siblings like add_contact_tag or list_contact_fields, but the custom-field wording is enough to separate it from the tag and listing tools 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 description gives clear working context by telling the agent where to source parameters: 'user_ns from find_contact' and 'field_name from list_contact_fields'. It does not explicitly state when not to use it or name alternatives, but the preconditions are concrete enough for correct selection and sequencing.

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?

There are no annotations, so the description carries the full behavioral burden. It explicitly warns 'Write: customer-visible; may send WhatsApp messages,' which discloses important side effects and customer impact beyond what the schema shows.

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 add distinct value: the action, the parameter provenance, and the side-effect warning. The most important information is front-loaded, and there is no filler.

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

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

For a simple two-parameter trigger with no output schema, the description covers purpose, parameter sources, and behavioral side effects. It does not mention return values or when not to use it, but the essential invocation guidance is present.

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

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

Schema description coverage is 0%, but the description compensates by tying each parameter to a sibling tool output. This is meaningful added context, though it does not explain the expected format or deeper semantics of user_ns or flow_name.

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 begins with a specific verb and resource: 'Send a contact into a sub-flow.' This clearly distinguishes the tool from message-sending siblings like send_text and send_whatsapp_template, and explains what trigger_flow actually does.

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

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

It gives concrete sourcing guidance for both required parameters: 'user_ns from find_contact; flow_name from list_flows.' This clearly implies when to use the tool and how to prepare inputs, though it does not explicitly name alternatives or exclusions.

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

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

With no annotations present, the description carries the full behavioral burden. It does disclose that this is a write operation and that it 'reroutes the conversation,' but it does not mention side effects, fail states, or whether an assignment must already exist.

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

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

The description is compact and front-loaded, with each short phrase adding distinct value: the core action, the parameter source, and the behavioral effect. There is 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 one-parameter mutation tool, the description covers what it does, where the parameter comes from, and the resulting behavior. It is largely complete, though additional context about when not to use it or expected failure modes would strengthen 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 schema provides only the parameter name and title, so the description's note that `user_ns` comes from `find_contact` adds valuable provenance. However, it does not explain the format or semantics of `user_ns` beyond that.

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: 'Clear the human-agent assignment on a contact's chat.' This clearly identifies the verb, resource, and scope, and is distinct from siblings like assign_agent and assign_agent_group.

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 useful procedural context by specifying that `user_ns` comes from `find_contact`, but it does not explicitly explain when to prefer this over assign_agent or other alternatives. Usage is implied rather than fully stated.

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