neuron

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

Description adds that the bot will respond to messages, which clarifies behavior beyond annotations. However, it does not disclose side effects (e.g., whether it disconnects existing channels) or error conditions. Annotations are present but not contradicted.

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, front-loaded with the action. No extra words, every sentence adds value.

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

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

For a 2-parameter tool with no output schema, the description covers the basic purpose and a behavioral trait (bot responds), but omits details like return format or error handling. Could be more complete.

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

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

Schema covers 100% of parameters with descriptions. Description does not add any further semantic detail 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?

Description clearly states the tool connects an additional WhatsApp channel to a bot as a secondary number. It specifies the resource (bot and channel) and the action (connect), and distinguishes from siblings like 'assign_bot_to_channel' by emphasizing 'additional' and 'secondary number'.

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?

Description implies the tool is for adding a secondary channel (not the first), but does not explicitly state when to use this vs. siblings like 'assign_bot_to_channel'. No prerequisites or exclusions are provided.

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

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

Annotations provide no hints (all false), so the description carries the burden. It discloses the key behavior that phone numbers without matching contacts are auto-created as minimal records, which adds value beyond the schema.

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

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

Two concise sentences, front-loading the main action and then adding a critical behavioral detail. No redundant information.

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

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

With no output schema, the description could mention return values or error conditions (e.g., what happens if the list doesn't exist). However, it covers the essential behavior adequately for a simple add 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 coverage is 100%, but the description adds context by explaining that phone numbers may trigger contact creation, clarifying the purpose of the entries parameter beyond the schema's description.

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

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

The description clearly states the action (add one or more contacts) and the resource (a list), with specific identifiers (contact ID or phone number). The auto-creation detail distinguishes it from similar tools like neuron_create_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?

The description implies usage for adding contacts to an existing list, but does not explicitly mention when not to use or provide alternatives such as neuron_remove_from_contact_list or neuron_create_contact_list.

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

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

The description adds value beyond annotations by noting that secrets are 'encrypted at rest,' which is a behavioral detail not captured in annotations. It aligns with the idempotentHint and destructiveHint annotations (non-destructive, safe to repeat).

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: two sentences that cover purpose, security, and context. It is front-loaded with the key action and resource, wasting no words.

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

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

For a simple credential management tool with full schema coverage, the description is complete. It communicates the essential purpose and security feature. However, it could optionally mention that it works with existing tool IDs, but this is already implied by the 'id' parameter.

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

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

The input schema covers all three parameters with descriptions, achieving 100% coverage. The description does not add parameter-specific meaning beyond the schema, but the schema itself is adequate. Hence a baseline score of 3 is appropriate.

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

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

The description clearly states the verb ('Store or update'), the object ('secret credential'), and the context ('for a custom tool integration'). It distinguishes the tool from its sibling 'neuron_remove_tool_secret' by focusing on storage/update rather than removal.

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 context ('for a custom tool integration') but does not explicitly state when to use this tool versus alternatives or provide exclusion criteria. The distinction from 'neuron_remove_tool_secret' is implicit rather than explicit.

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 contradicts the annotations. It claims 'idempotent — re-applying or swapping personas replaces it cleanly', while annotations set idempotentHint to false. This is a direct contradiction, so the score is 1 as per the rules.

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 that front-loads the primary purpose ('Give a bot this persona's voice') followed by concise behavioral details. No filler or redundant 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?

The description adequately covers the tool's behavior for a simple operation with only two parameters and no output schema. It explains the mutation, idempotency, and metadata tagging. However, it could have explicitly warned about the modifying effect, but that is implied by 'merges' and 'tags'.

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

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

Schema description coverage is 100%, with both 'id' and 'botId' clearly described as 'Persona UUID' and 'Bot UUID to apply the voice to'. The description adds minimal extra meaning beyond the schema, not significantly enhancing parameter understanding.

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

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

The description clearly states the tool's function: 'Give a bot this persona's voice' and explains the mechanism ('merges a delimited voice block into the bot's system prompt' and 'tags the bot's metadata with the persona id'). This is specific and distinguishes it from related tools like build_persona or update_bot.

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

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

The description provides clear context for when to use (applying a persona's voice to a bot) and the idempotency note ('re-applying or swapping personas replaces it cleanly') guides usage for repeated or swapping scenarios. However, it does not explicitly mention alternative tools or when not to use this one.

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 explains the effect of approval (incorporating insight), which adds behavioral context beyond annotations. Annotations indicate idempotent and non-destructive; description is consistent and provides meaningful insight about state changes.

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 that conveys the purpose and effect without any wasted words. It is efficient and easy to parse.

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

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

For a simple tool with one parameter, good annotations, and no output schema, the description is sufficient. It could optionally mention that the reflection must exist or that approval is permanent, but it is not necessary.

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

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

Schema coverage is 100%, and the parameter 'id' is already well-described in the schema. The description adds no extra semantics beyond what the schema provides, leading to a baseline score of 3.

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

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

The description clearly states the action (approve), the object (bot-generated reflection), and the outcome (incorporate insight into future behavior). It distinguishes from sibling tools like 'reject_reflection' and 'list_reflections'.

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 tells the main use case but does not explicitly mention when not to use it or suggest alternatives (e.g., 'neuron_reject_reflection' for rejecting). A clearer 'when to use vs. alternatives' statement would improve it.

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

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

The description adds value beyond annotations by stating it 'replaces any previously assigned bot', which complements the idempotentHint=true and destructiveHint=false. It does not contradict annotations and provides useful behavioral context, though it could mention prerequisites like channel existence.

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

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

The description is concise: two sentences, 16 words total. It is front-loaded with the verb and action, and every sentence contributes meaningful information. No waste.

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

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

Given the simplicity (two params, no output schema), the description covers the key operation and replacement behavior. It is mostly complete, but could mention that the action is idempotent (though annotations cover that) or what happens after assignment (e.g., confirmation). Still, it provides adequate context for an agent to use 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 coverage is 100%, so the baseline is 3. The description rephrases the parameters but does not add semantic details beyond what the schema already provides (e.g., UUID format). It supplies context for the overall operation, but not parameter-specific 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 clearly states the action ('Assign'), the resource ('bot to handle incoming messages on a specific WhatsApp channel'), and includes a critical behavioral note ('Replaces any previously assigned bot'). This distinguishes it from related siblings like 'unassign_bot_from_channel' and 'assign_bot_to_social_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 when to use (for assigning a bot to a WhatsApp channel) and notes the replacement behavior, but does not explicitly list alternatives or when not to use it. The context is clear, but lacking direct exclusions or comparisons to other 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 indicate idempotentHint=true and destructiveHint=false. The description adds value by explaining that the bot gains credential access, which is beyond the annotations. No contradictions found.

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, front-loaded with the action and resource, no unnecessary words. Every sentence adds value.

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

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

Given no output schema, the description adequately explains the purpose and effect. However, it could elaborate on what 'handle interactions' entails (e.g., read/send messages), but the current level is 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 coverage is 100% and each parameter has a clear description (UUID of social channel, UUID of bot). The description adds no additional meaning, 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 ('Assign a bot') and the resource ('social channel'), and explains the effect (bot uses channel's credentials). It distinguishes from siblings like 'neuron_assign_bot_to_channel' by specifying 'social' 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 the tool is for assigning bots to social channels, but it does not provide explicit guidance on when to use this vs alternatives (e.g., when the channel is not social), nor does it mention prerequisites or conditions.

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 indicate mutation (readOnlyHint=false) but no destructive or idempotent hints. The description does not disclose behavioral traits beyond the action; it omits information about required permissions, idempotency (e.g., re-attaching), or side effects.

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: first defines the action and purpose, second explains the optional parameter. Front-loaded and no unnecessary words.

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

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

Given 3 parameters and no output schema, the description covers the core action and parameter, but lacks information about return values, error conditions, or effects of re-attachment. Adequate but not complete.

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

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

Schema coverage is 100% with descriptions for all parameters. The description adds context that priority determines retrieval order when multiple knowledge bases are attached, but this is a minor addition to the schema's own description of priority.

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 'attach a knowledge base to a bot' and its purpose 'enhance its responses with domain-specific knowledge'. It also mentions the optional priority parameter, distinguishing it from sibling tools like detach.

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 when to use (when you want to attach a knowledge base) but does not explicitly state conditions for use, alternatives, or when not to use. Sibling detach tool exists but no comparison is given.

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 indicate readOnlyHint=false (write operation) and destructiveHint=false. The description adds that the tool 'automatically saves' the contact, which is consistent with a non-destructive write. No contradictions, but missing details on duplicate handling or error behavior. Annotations lower the bar, so 4 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?

Two sentences, 22 words. Extremely concise with no waste. Front-loads the main actions (transcribe, extract, save).

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?

No output schema exists, but the description fails to explain what the tool returns. It mentions saving the contact but not the response format. Also missing audio size limits or error handling. Gaps in completeness for a tool with no output schema.

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%, so baseline is 3. The description doesn't add meaning beyond what the schema provides: audioBase64 is base64 audio, audioFormat is format hint. No examples or additional constraints.

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

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

The description clearly states the tool transcribes audio and extracts contact information (name, phone, email, notes, tags), then automatically saves it. The verb 'transcribe' and 'extract' are specific, and the tool distinguishes itself from siblings like 'create_contact' by focusing on audio input.

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?

No explicit guidance on when to use this tool versus alternatives (e.g., if you already have text contact info, use 'create_contact'). The description implies use with audio containing contact details but lacks exclusions or context for when not to use it.

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

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

Annotations already indicate destructiveHint=true and idempotentHint=true. The description adds valuable behavioral context by explaining the consequences for the blocked contact (cannot message or see profile), which goes beyond the annotations.

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

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

Only two sentences, front-loaded with the core action, and every word serves a purpose. 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 straightforward block operation, the description covers the effect on the contact and implies it is permanent (unless undone via unblock). No output schema exists, but the consequences are sufficiently explained.

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

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

Schema coverage is 100% and both parameters ('jid' and 'channelId') are well described in the schema. The description does not add additional parameter-level details, so a baseline of 3 is appropriate.

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

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

The description uses a specific verb ('Block') and resource ('WhatsApp contact'), and clearly states the consequences (cannot message the bot or see its profile), easily distinguishing it from siblings like 'unblock_contact' or 'delete_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?

The description provides clear context on what blocking does but does not explicitly guide when to use it versus alternatives (e.g., 'unblock_contact', 'mute', or 'delete_contact'). No when-not-to-use or alternative references are included.

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 indicate this is not read-only nor destructive, and description adds that it produces a streaming or complete AI-generated response. It also notes the API key requirement. This complements the sparse annotations well, though it does not detail side effects like conversation state changes.

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 unnecessary words. It front-loads the action and key requirement (API key). However, it could be slightly improved by structuring the streaming/response modes more explicitly.

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 no output schema, the description should explain the response format or behavior (e.g., streaming mechanics). It mentions streaming or complete response but lacks details on how the response is delivered. For a chat tool, this is a notable gap.

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

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

Schema coverage is 100%, so parameters are fully documented in the input schema. The description does not add additional meaning beyond what's in the schema, such as explaining the role of 'contactName' or 'contactPhone' in conversation context. 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 sends a message to a bot via API and receives an AI-generated response. It distinguishes from siblings like 'neuron_bot_api_send' by specifying the AI response nature, and from 'neuron_bot_api_get_messages' by being a send operation.

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

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

The description provides basic usage context (requires API key, sends message), but does not explicitly state when to use this tool over siblings like 'neuron_bot_api_send' or 'neuron_send_message'. No exclusions or alternative recommendations are given.

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 safe behavior; description adds minimal context about retrieving configuration/status but lacks details on error handling or invalid key behavior. No contradiction.

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, 16 words, front-loaded with verb and resource. No unnecessary words.

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

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

Given the tool's simplicity (1 param, annotations present, no output schema), the description sufficiently covers what the tool does and the authentication requirement, though could elaborate on returned data scope.

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

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

Schema coverage is 100% and description for apiKey is identical to schema's description, adding no new meaning. Baseline score 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?

Description uses specific verb 'Retrieve' and resource 'configuration and status information', clearly distinguishing from sibling tools like neuron_get_bot by specifying the bot is identified via API key.

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

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

Description implies usage for bot API key holders but does not explicitly state when to use this tool over alternatives such as neuron_get_bot, nor provides when-not-to-use guidance.

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

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

Annotations already declare readOnlyHint=true, destructiveHint=false, and idempotentHint=true. The description adds that it uses cursor-based pagination and requires API key authentication, which provides some additional behavioral context. However, it does not explain pagination behavior, error handling, or rate limits. With annotations covering safety, a 3 is appropriate.

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

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

The description is extremely concise at two sentences, front-loading the main purpose and then adding the authentication requirement. 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?

Given that the tool has no output schema, the description should at least hint at the return format or pagination details (e.g., what the cursor represents or that it returns an array of messages). It is adequate but could be more complete for a tool with moderate 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 description coverage is 100%, so the input schema already documents all four parameters thoroughly. The description offers no additional parameter-level meaning beyond what the schema provides. Baseline of 3 is correct.

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 retrieves message history for a specific conversation using cursor-based pagination. It specifies the verb 'retrieve' and resource, but does not differentiate from the sibling 'neuron_get_messages' which likely has a similar purpose, so it misses full distinction.

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 mentions a prerequisite (requires API key) but provides no guidance on when to use this tool over alternatives like 'neuron_get_messages' or other bot API tools. There is no mention of appropriate contexts 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?

Annotations already indicate readOnly, idempotent, non-destructive. Description adds authentication requirement, pagination, and filtering capability, providing context beyond annotations.

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

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

Single sentence with two short clauses; front-loaded with key action and no redundancy. Every word adds value.

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

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

Covers core purpose, auth, pagination, and filtering. Lacks details on response structure or pagination defaults, but for a simple list tool it is 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 coverage is 100%, so parameters are already well-described. The tool description only reiterates 'filtering by conversation status' without adding new meaning for each 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 the tool retrieves a paginated list of conversations managed by the bot, with filtering by status. It distinguishes from siblings like 'get_conversation' (single) and 'close_conversation' (mutate) by specifying scope and pagination.

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?

Description mentions filtering and API-key requirement, implying when to use. However, it does not explicitly state when not to use or compare with alternatives like 'list_conversations' (non-bot API) or 'get_conversation'.

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 are all false (readOnlyHint=false, destructiveHint=false), indicating no special behavior. The description adds minimal transparency beyond the obvious write operation ('Send'). It mentions requiring an API key but does not disclose rate limits, failure modes, or security considerations beyond what is in the schema.

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

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

The description is two sentences, front-loaded with the core purpose. Every word adds value, and there is no redundant or unnecessary information. It is appropriately sized for the tool's complexity.

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

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

Given the tool has 7 parameters, 3 required, and no output schema, the description covers the essential action and supported message types. However, it lacks details on return values or side effects. The annotations provide no additional context, so the description bears the full burden but is mostly adequate.

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

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

Schema description coverage is 100%, so all 7 parameters are already documented in the input schema. The description adds marginal value by mentioning support for text and media, hinting at messageType and mediaUrl, but does not elaborate on any parameter semantics beyond what the schema provides.

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

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

The description clearly states the verb 'Send', the resource 'outbound message through the bot API', and the scope 'to a specified phone number'. It distinguishes this tool from siblings like 'neuron_send_message' or 'neuron_bot_api_chat' by specifying 'bot API' and mentioning support for text and media 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 context (requires API key) but does not provide explicit guidance on when to use this tool versus alternatives such as neuron_send_message, neuron_bot_api_chat, or other send-related siblings. No exclusions or when-not scenarios are mentioned.

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

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

Annotations already declare readOnlyHint=true, idempotentHint=true, and destructiveHint=false. The description confirms a read-only browse operation but adds no additional behavioral details (e.g., rate limits, authentication requirements, or result 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 a single, efficient sentence (14 words) that front-loads the purpose and filtering options without any superfluous information.

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

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

Given the lack of an output schema, the description does not explain what the tool returns (e.g., list details). However, for a browse operation the core purpose is clear, and the schema covers all input parameters.

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

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

Schema description coverage is 100% with each parameter having a description. The description mentions filtering by 'category, region, or search term', which maps to three of the five parameters, but does not add significant meaning beyond the schema.

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

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

The description clearly states the action ('Browse'), the resource ('verified contact lists in the shared marketplace pool'), and filtering capabilities. It distinguishes from siblings like neuron_browse_pool (likely for other pool items) by specifying 'contact lists'.

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

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

The description implies usage for discovering available contact lists but does not provide explicit when-to-use or when-not-to-use guidance, nor does it reference alternatives like neuron_browse_pool or neuron_get_pool_item.

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

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

Annotations already indicate the tool is read-only, idempotent, and non-destructive. The description adds that browsing includes optional filtering, but does not disclose additional behavioral traits beyond what annotations provide.

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 concise sentence that front-loads the action and resource, with no unnecessary 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?

The description covers the main purpose and filtering options adequately. Minor gaps include lack of explanation about pagination defaults or return format, but schema descriptions partially compensate.

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 7 parameters have descriptions in the schema (100% coverage). The description summarizes filtering options but does not add meaning beyond the schema, such as format or defaults.

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 browses a shared marketplace pool of specific resource types with filtering options. However, it does not differentiate from the sibling tool 'neuron_browse_list_pool', which likely serves a similar 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 for browsing and filtering pool items but provides no explicit guidance on when to use this tool versus alternatives or what prerequisites are needed.

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 all annotation hints set to false, the description carries the burden of behavioral disclosure. It adds valuable context: runs an LLM call with a few seconds latency, and requires a minimum sample size. It also implies a non-destructive analysis operation (reverse-engineering) rather than deletion. However, it doesn't explicitly state whether a persistent persona record is created or how it integrates with existing persona management, which would be useful.

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: the first sentence packs the core purpose and output components, the second efficiently covers the precondition and latency. Every word earns its place; there is no fluff 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?

Given there is no output schema, the description helpfully lists the expected outputs (voiceProfile components and exemplars). It also covers eligibility (>=3 samples) and performance (LLM call, few seconds). It would be even more complete if it explicitly described the return format or any side effects (e.g., whether a new persona is saved), but for this complexity level it is quite adequate.

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 descriptions for all three parameters, including defaults and meanings (e.g., sampleLimit describes 'top-engagement items to analyze'). The tool description echoes this ('top-engagement items') but adds no new parameter-level semantics. Since schema coverage is 100%, the baseline of 3 is appropriate.

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

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

The description opens with a specific verb ('Distill') and clearly identifies the input (Collection of mined content) and the output (voiceProfile with enumerated components like tone, diction, cadence, emoji/formatting habits). It distinguishes this from sibling tools such as neuron_apply_persona_to_bot (applies an existing persona) and neuron_generate_from_persona (uses a persona to generate content), establishing this as the persona-creation-from-content step.

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 build a reusable persona from a collection of mined content, and it adds a concrete precondition (collection must have >=3 usable samples). It doesn't explicitly name alternatives or state when not to use, but the purpose is so focused that the usage scenario is clear. Could have mentioned 'use this instead of manual persona creation' but not essential.

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 safety and idempotency details. The description adds the 'bulk' aspect but does not disclose potential failure scenarios or edge cases. Given rich annotations, the additional context is modest.

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 only two sentences with no extraneous information. It is front-loaded and efficient, earning 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 bulk toggle operation with good annotations, the description is fairly complete. It could mention success indicators or failure handling, but the idempotent hint and non-destructive nature mitigate this need.

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%, so the parameters are fully described in the schema. The description does not add additional meaning or constraints beyond what is already in the schema, so baseline score of 3 is appropriate.

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

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

The description clearly states the action (enable or disable) and resource (multiple built-in tools for a bot). It distinguishes from the sibling tool 'neuron_toggle_builtin_tool' by emphasizing bulk operation and efficiency.

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 indicates when to use this tool (for bulk operations) and implies it is more efficient than the singular version, but does not explicitly state when not to use it or mention alternatives beyond the sibling.

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 idempotentHint=true, so the safe read nature is clear. The description adds context about browsing marketplace campaigns, but does not disclose additional behavioral traits like pagination details or result ordering.

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 is concise and front-loaded with the key action and resource. No redundant information.

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

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

For a read-only browse operation with pagination, the description adequately explains the purpose. Without an output schema, the return values are not detailed, but the context of browsing campaigns to join is sufficient. Sibling tools are many, but the description distinguishes by marketplace focus.

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% (page and limit parameters are documented in the schema). The description does not add extra meaning beyond what the schema already provides, 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 tool browses available campaigns in a marketplace for joining to earn rewards. It specifies the resource (campaigns in marketplace) and action (browse), distinguishing it from other list tools like neuron_list_campaigns which likely show user's own campaigns.

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 tool is for browsing available campaigns to join, but does not explicitly state when to use it versus alternatives like neuron_list_campaigns or neuron_browse_pool. No exclusions or conditions are provided.

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

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

Annotations already declare readOnlyHint=true, destructiveHint=false, idempotentHint=true. The description adds that it returns delivery counts and rewards, and that it applies only to owned campaigns. This provides useful context beyond annotations without contradiction.

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 of 18 words, front-loaded with action and purpose. No redundant information. Every word earns its place.

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

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

For a simple list tool with one parameter and no output schema, the description covers the core functionality and return data. Could optionally mention pagination or success/error expectations, but given annotations and schema, it is mostly complete.

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

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

Schema coverage is 100% with the single 'id' parameter described as 'Unique identifier (UUID) of the campaign you own'. The description does not add further parameter meaning beyond restating the concept of ownership, 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 it retrieves participants of owned campaigns with specific data (delivery counts, earned rewards). This distinguishes it from sibling tools like neuron_get_campaign (campaign details) and neuron_list_campaigns (list campaigns). The verb 'Retrieve' and resource 'participants' are specific.

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 indicates ownership requirement ('campaign you own'), which implies usage by campaign owners. It does not explicitly state when to use vs alternatives like neuron_get_campaign or neuron_my_participations, but the context of a read-only list for owners is clear. Missing explicit exclusions or alternative references.

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 destructiveHint=true and idempotentHint=true. The description adds useful behavioral context beyond those: it fires the approval.cancelled callback and only acts on still-pending approvals. This gives the agent a clearer model of side effects and preconditions.

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 the core action front-loaded and supporting details kept brief. The parenthetical example is short and valuable. No redundant or extraneous wording.

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

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

For a simple cancellation tool with comprehensive annotations and full schema coverage, the description is complete. It covers purpose, when to use, side effects, and authentication, without needing to explain return values (no output schema). The agent has enough to use 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 coverage is 100% with clear descriptions for apiKey and approvalId. The description does not add new parameter semantics; it only repeats the need for a bot API key. Baseline 3 is appropriate when the schema carries the parameter documentation.

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

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

The description states 'Cancel a still-pending approval' with a specific verb, resource, and scope. It also provides an example ('upstream action was aborted') and clearly distinguishes itself from approval request/response tools in the sibling list by focusing on cancellation.

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

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

It gives a clear context for when to use the tool: to cancel an approval that is still pending, such as when the original action was aborted. It also notes the requirement for a bot API key. However, it does not explicitly name alternative tools or exclusion criteria, 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?

The description adds behavioral context beyond annotations: it reveals that cancellation is irreversible and contingent on the message's status being 'scheduled'. Annotations already indicate destructiveHint=true and idempotentHint=true, and the description aligns with those. It does not detail side effects or error behavior, but for a simple cancel 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?

The description is two short sentences with no wasted words. The key action and constraint are front-loaded in the first sentence. Every sentence adds value 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 simple tool with one required parameter and no output schema, the description covers the essential aspects: purpose, precondition (scheduled status), and irreversibility. It does not explain the return value or error cases, but these are often inferred for a cancel operation. The description is sufficient for an agent to use the tool correctly given the context.

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

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

Schema description coverage is 100% and the single parameter 'id' is already described as the UUID of the scheduled message. The description does not add any additional meaning or context about the parameter, so it relies entirely on the schema. 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 'Cancel a scheduled message' and specifies the resource. It also provides a condition (only scheduled messages) that distinguishes it from other message-related tools like delete or update. Although it doesn't explicitly name sibling alternatives, the verb and constraint make the purpose unambiguous.

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

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

The description explicitly states when to use: to prevent a scheduled message from being sent, and notes that only messages with status 'scheduled' can be cancelled. It also warns that the action cannot be undone. It does not explicitly say when not to use or compare to alternatives like update_scheduled_message, but the guidance is clear for most scenarios.

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

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

Annotations already declare destructiveHint=true and idempotentHint=true. The description adds the important behavioral detail that 'Access continues until the end of the current billing period', which goes beyond what annotations provide.

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 fluff. Every word adds value.

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

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

For a simple cancellation tool with no parameters and no output schema, the description covers the key behavioral aspects and is sufficiently complete for an agent.

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

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

There are zero parameters and the schema coverage is 100%. The description does not need to add parameter details. It 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 verb 'Cancel' and the resource 'current active subscription', and adds the important detail that access continues until the end of the billing period. This distinguishes it from sibling tools like get_billing or checkout.

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 the agent wants to cancel an active subscription. It does not explicitly state when not to use it or provide alternatives, but the purpose is clear enough for an agent to decide.

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 have readOnlyHint=false, consistent with a write operation. The description mentions initiating a checkout and returning a URL/confirmation, but lacks detail on side effects, authentication needs, or rate limits.

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

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

Two sentences with no fluff. First sentence states action, second states output. Front-loaded and efficient.

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

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

For a single-parameter tool with no output schema, the description covers basic purpose and output but omits prerequisites, whether upgrade requires existing subscription, and details about the return format.

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% with one parameter fully described (plan enum). The description adds no extra meaning beyond the schema, so baseline of 3 is appropriate.

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

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

The description clearly states the verb 'Initiate' and resource 'checkout session' for a subscription plan upgrade, and mentions the output. It is distinct from siblings like neuron_cancel_subscription.

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 upgrading an existing subscription but does not explicitly state when not to use it or mention alternatives. No guidance on prerequisites or context.

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 provide idempotentHint=true and destructiveHint=false. The description adds behavioral details beyond annotations: the bot stops responding and the conversation is archived. No contradictions found.

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 very concise with two sentences. The first sentence clearly states the action and its effect; the second adds key details. No wasted words.

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

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

Given one parameter, no output schema, and annotations covering safety, the description is largely complete. It explains the purpose and immediate effects. Missing details like whether the operation can be reversed or the return value, but these are not critical for an idempotent close action.

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

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

Schema coverage is 100% and the single parameter 'id' is already described as 'Unique identifier (UUID) of the conversation to close'. The description does not add further semantic value 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 clearly states 'Close an active conversation' with specific outcomes ('bot stops responding', 'conversation is archived'). It distinguishes from sibling tools like neuron_release_conversation (likely reopens) and neuron_takeover_conversation (transfers control).

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 specifies the tool is for active conversations and indicates the result (completed, archived, bot stops). While it does not explicitly state when not to use it or list alternatives, the context is clear enough for most use cases.

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 provide no hints (all false), so the description carries the burden. It discloses that the tool creates a new conversation if one does not exist, which is a key behavioral trait. However, it does not detail any other side effects, error conditions, or what happens if the conversation already exists.

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

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

Two concise sentences with no wasted words. The purpose is front-loaded in the first sentence, and the second adds a valuable detail about conversation creation. Structurally efficient.

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

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

Given 7 parameters, no output schema, and many sibling tools, the description covers the basic operation and auto-conversation creation. But it omits return value, failure modes, and permission requirements, leaving some gaps for an agent.

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

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

Schema coverage is 100% with clear descriptions for each parameter (e.g., E.164 format for 'to', ISO 8601 for 'sendAt'). The top-level description adds minimal extra semantics beyond the schema, 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 it composes and sends a new message to a phone number via a specific channel, and it mentions automatic conversation creation. However, it does not explicitly differentiate from similar sibling tools like neuron_send_message or neuron_send_whatsapp, leaving some ambiguity.

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

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

No explicit guidance on when to use this tool versus alternatives. It does not mention prerequisites, such as needing an active channel, or when not to use it.

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

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

Annotations already establish that this is a write operation (readOnlyHint: false) and not destructive (destructiveHint: false). The description adds the phone-bearing prerequisite and the optional list addition, which is useful. However, it does not disclose whether the original lead record is removed, kept, or modified after conversion, nor any permission requirements. This is additional context beyond the annotations but still leaves room for more transparency.

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

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

The description is a single sentence with a parenthetical clarification. It is front-loaded with the main action and contains no filler. Every phrase earns its place, making it concise and well-structured.

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

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

For a tool with two parameters and no output schema, the description covers the purpose, the prerequisite, and the optional behavior. It could be more complete by explaining the fate of the original lead (e.g., whether it is deleted or kept) and what is returned. However, for a simple conversion action, the description provides enough context for an agent to select and invoke it appropriately.

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% for both parameters, so the schema already documents 'id' as a Lead UUID and 'addToList' as a contact list name. The description adds meaning by explaining that the lead must be phone-bearing and that adding to a list is optional, which slightly enhances the schema. This aligns with the baseline 3 for high schema coverage.

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

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

The description clearly states a specific action: 'Promote a phone-bearing lead into a contact.' It identifies the resource (lead), the target (contact), and the prerequisite (phone-bearing). The parenthetical explains the benefit, and the scope distinguishes it from sibling tools like 'create_contact' (which creates from scratch) and 'add_to_contact_list' (which adds an existing contact to a 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 when to use the tool: when you have a lead that should become a contact, particularly to enable messaging or list addition. It states the prerequisite (phone-bearing) but does not explicitly name alternatives or exclusion conditions. Since sibling tools like 'neuron_create_contact' and 'neuron_add_to_contact_list' exist, mentioning them would be beneficial, but the context is clear enough for a 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?

With all annotations false, the description carries the full burden. It adds value by disclosing a financial impact ('Deducts from wallet upon approval'), but omits other important behaviors like approval requirements, reversibility, or what happens on failure. The single behavioral detail is useful but insufficient for full transparency.

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

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

The description is a single sentence that efficiently conveys the purpose and a key behavioral aspect. Every word earns its place; 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?

Given no output schema, the description should cover return values and state changes. It only mentions a side effect (wallet deduction) but omits what the tool returns (e.g., ad request ID, status) and any preconditions or permissions. For a tool with nested objects and financial implications, more context 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 schema has 100% parameter description coverage, so the description need not add much. It does provide contextual tie-in for 'budget' (deducts from wallet), but overall adds little extra meaning beyond the schema's own descriptions. 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 ('Create') and the resource ('ad distribution request'), specifying the target ('contacts in pool lists matching target demographics') and a key side effect ('Deducts from wallet upon approval'). It distinguishes itself from sibling 'create_*' tools by focusing specifically on ad requests.

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

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

The description explicitly states the use case ('to send a message to contacts in pool lists matching target demographics'), making it clear when to use. However, it does not provide exclusions or mention alternatives (e.g., 'neuron_update_ad_request' for existing requests), which would enhance guidance.

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

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

The description discloses the key behavioral trait that the API key cannot be retrieved later, which is not covered by annotations (destructiveHint=false, readOnlyHint=false). This is valuable context for the agent about the irreversible nature of the action.

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 purpose, and every word adds value. 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?

While the description covers the purpose and a key behavioral note, it does not mention the format of the response (e.g., the key itself) or any required permissions. For a creation tool with 3 parameters, it is functional but missing some contextual detail.

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%, so the baseline is 3. The description reinforces the botId parameter by mentioning 'a specific bot' but adds no new detail for name or expiresAt 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 action ('Create a new API key'), the resource ('API key'), and the purpose ('for programmatic access to a specific bot'). It also adds a critical security note that the key cannot be retrieved later, which is distinctive among siblings like neuron_list_api_keys and neuron_revoke_api_key.

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

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

The description does not provide any guidance on when to use this tool versus alternatives, nor does it mention prerequisites (e.g., bot must exist) or exclusions. It only describes the action without contextual usage hints.

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 are neutral (readOnlyHint: false, etc.), so the description carries the burden. It discloses that the tool creates a post and supports rich content (markdown, HTML). However, it does not mention side effects, required permissions, or whether the operation is idempotent. The description adds some context but could be more detailed.

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 brief (two sentences) and front-loaded with the core purpose. The second sentence efficiently lists content capabilities without unnecessary words. Every sentence serves a purpose, making it highly concise.

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 10 parameters and no output schema. The description covers creation behavior and content features but omits return value, error handling, and prerequisites. For a complex tool, this is adequate but not complete. More details on output or failure modes would improve completeness.

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

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

Schema description coverage is 100%, so baseline is 3. The description adds value by elaborating on the 'content' parameter's supported formats (markdown, HTML, embeds), which goes beyond the schema. However, for other parameters like tags or excerpt, it merely mentions them without further detail. Overall, it adds moderate semantic value.

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

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

The description clearly states the tool's purpose: creating a new blog post with status (draft/published), title, content, and optional metadata. It uses a specific verb and resource, making the action distinct. However, it does not explicitly differentiate from sibling tools like update_blog_post or publish_blog_post, which would warrant a 5.

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

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

The description provides no guidance on when to use this tool versus alternatives. It does not mention prerequisites, when not to use it, or how it relates to other blog post tools. This limits an agent's ability to select the correct 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?

The description discloses that it returns the created bot object, which is useful. However, it does not mention side effects, permissions required, idempotency, or error conditions. With no annotations beyond readOnlyHint=false and destructiveHint=false, the description provides minimal behavioral context beyond the implicit mutation.

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 sentence of 17 words is concise and front-loads the action. However, it could be slightly improved by including the return value (already present) and hinting at the optional parameters. Still efficient and well-structured.

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

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

Given the tool has 13 parameters, nested objects (metadata with detailed keys), and no output schema, the description adequately states the basic purpose and return value. The schema fills the gaps, but a brief mention of common optional fields would improve completeness. Score 3 is adequate.

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

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

Schema description coverage is 100%, so the schema already documents all 13 parameters well. The description only references 'name, model, and behavior instructions' (a subset) without adding new meaning. Baseline 3 is appropriate since the schema does the heavy lifting.

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

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

The description clearly states 'Create a new AI bot' using a specific verb and resource. It mentions key parameters (name, model, behavior instructions) that distinguish it from other creation tools. While it doesn't explicitly differentiate from siblings, the unique resource 'bot' makes purpose unambiguous.

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

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

No guidance on when to use this tool vs alternatives such as update_bot, delete_bot, or other create_* tools. There are no prerequisites, exclusions, or context provided to help the agent decide between creating a bot versus other actions.

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

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

Annotations only indicate that the operation is not read-only, not idempotent, not open-world, and not destructive, which is limited. The description adds meaningful behavioral context: the broadcast is created in draft status (not sent immediately) and the channel is auto-resolved if omitted. This goes beyond the annotations and helps the agent understand the tool's behavior.

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

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

The description is three short sentences, front-loaded with the core purpose, and every sentence contributes useful information. There is no redundancy or filler, making it easy to parse quickly.

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

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

For a tool with 9 parameters and no output schema, the description covers the essential usage patterns: draft status, recipient specification options, and channel auto-resolution. It does not explain every parameter, but the schema descriptions are comprehensive, and the description provides enough context for an agent to invoke the tool correctly. It could mention the relationship to send_broadcast for full completeness, but it is adequate.

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 covers 100% of parameters with descriptions, providing a strong baseline. The description adds value by summarizing the key decision between 'recipients' and 'recipientSources' and noting that 'channelId' can be omitted due to auto-resolution, which helps the agent understand parameter relationships without reading all schema details.

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

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

The description clearly states the verb ('Create'), resource ('broadcast message'), and status ('draft'), which distinguishes it from sibling tools like neuron_send_broadcast and neuron_update_broadcast. It also mentions the key alternatives for specifying recipients, making the purpose unambiguous.

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

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

The description provides clear context: it creates a draft, so it is for creating rather than sending. It also explains the two ways to provide recipients and the auto-resolution of the WhatsApp channel. However, it does not explicitly mention when to use this tool over alternatives like neuron_send_broadcast, stopping short of full when/when-not guidance.

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

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

Annotations are all false, so description carries the burden. It correctly indicates a write operation and adds the plan requirement. Could mention side effects or idempotency, but overall 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?

The description is a single sentence with no wasted words, plus a required condition. Front-loaded and efficient.

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

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

With no output schema, the description should mention what is returned (e.g., campaign ID). It also lacks references to related tools like fund_campaign or submit_campaign. Adequate but not complete.

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

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

Schema coverage is 100%, so baseline is 3. The description adds high-level context (target audience, template, schedule) but does not significantly enhance parameter meaning beyond what the schema provides.

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

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

The description clearly states the tool creates a new campaign, specifying key components (target audience, messaging template, schedule). It is easily distinguished from siblings like update_campaign, fund_campaign, etc.

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 mentions a prerequisite (Pro or Business plan) and implies creation usage, but does not explicitly contrast with alternatives like update_campaign or stop_campaign.

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 indicates this is a write operation (create) and provides conditional parameter requirements. Annotations already show readOnlyHint=false and destructiveHint=false. The description adds context about integration types but does not disclose additional behavioral traits such as idempotency, permission requirements, or side effects. Given limited annotations, more behavioral detail would be beneficial.

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: two sentences, each serving a distinct purpose. The first sentence states the core functionality, and the second sentence adds crucial conditional information. 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?

Without an output schema, the description does not explain return values. However, it covers the main purpose, integration types, and key parameter dependencies. For a creation tool of moderate complexity, this is largely sufficient, though it could mention potential errors or post-creation steps.

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

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

Schema description coverage is 100%, so the input schema already provides complete parameter descriptions. The description adds minimal value beyond restating the conditional requirement for meta_cloud type parameters. It does not explain parameter syntax or provide examples.

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 a new WhatsApp channel with two integration types (Meta Cloud API or Baileys). It uses a specific verb 'create' and resource 'WhatsApp channel', and distinguishes from sibling tools like neuron_create_social_channel by focusing on WhatsApp-specific integration.

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

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

The description explicitly states when to use this tool (for creating WhatsApp channels) and includes a conditional requirement: Meta Cloud channels need metaPhoneNumberId and metaAccessToken. However, it does not explicitly state when not to use it or compare it to alternatives like neuron_add_bot_channel or neuron_set_default_channel.

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

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

Annotations already indicate a non-read-only, non-destructive mutation. The description adds useful context about notes being saved as a structured entry with source tracking, which goes beyond the schema. However, it doesn't disclose potential side effects like duplicate contact handling or permission requirements.

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

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

The description is two sentences long, front-loaded with the primary action, and contains no unnecessary words. Every sentence adds value, and the additional note about notes is relevant.

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 create operation with 7 fully-described parameters and no output schema, the description is adequate. It clarifies the scope (organization's address book) and a key side effect (structured notes). It doesn't explicitly state the return value, but that is a minor gap given the schema richness.

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

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

Schema description coverage is 100%, so the parameters are fully documented in the schema itself. The description adds no additional meaning beyond what the schema already provides, except for briefly noting the notes behavior which is also in 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 clearly states 'Create a new contact in the organization's address book' with a specific verb and resource. It distinguishes from sibling tools like create_contact_list, update_contact, and delete_contact by targeting the contact resource specifically.

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

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

Usage is implied from the tool name and description, but no explicit guidance is given on when to use this versus alternatives like import_contacts or add_to_contact_list. The description does not provide exclusions or alternative recommendations.

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 are all false, so no contradictions. The description adds context about slug auto-generation and dynamic list criteria, which helps understand behavior. However, it does not disclose potential side effects, auth needs, or rate limits. For a creation tool, this is adequate but not exceptional.

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 at two sentences, covering the essential purpose and key behavioral notes without any superfluous information. It is well-structured 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?

The description covers the main aspects of creation, including auto-generated slug and dynamic list criteria. However, it does not describe return values or error conditions. Given the absence of an output schema, a bit more information on the response would improve completeness.

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

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

With 100% schema coverage, the schema already describes parameters. The description adds value by clarifying slug auto-generation and providing guidance on criteria for dynamic lists, going beyond the schema's simple descriptions.

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

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

The description clearly states the action ('Create') and resource ('new contact list'), and mentions key features like auto-generated slug and dynamic list criteria. This distinguishes it from sibling tools like neuron_add_to_contact_list or neuron_update_contact_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 when to use the tool (i.e., to create a new list) but does not explicitly state when not to use it or provide comparisons to alternative tools. The reference to dynamic lists and criteria provides some context, but lacks explicit usage guidance.

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

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

Annotations provide no behavioral hints (all false). The description only says 'Add', implying mutation, but does not disclose idempotency, authorization needs, conflict handling, or side effects beyond creation.

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 15-word sentence. It is front-loaded and without clutter, but the brevity sacrifices essential information, making it borderline under-specified.

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

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

Given the tool has 6 parameters, no output schema, and nested objects, the description is insufficient. It fails to explain return values, error cases, or how parameters relate (e.g., 'id' refers to the knowledge base).

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 6 parameters (100% coverage), so the baseline is 3. The description adds no extra meaning 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 'Add' and the resource 'new entry to a knowledge base', distinguishing it from creating the knowledge base itself (neuron_create_knowledge_base) and other CRUD operations on entries.

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?

No guidance is provided on when to use this tool, such as prerequisites (e.g., knowledge base must exist) or alternatives like neuron_ingest_knowledge. The description lacks context 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?

Annotations indicate readOnlyHint=false and destructiveHint=false, aligning with a create operation. However, the description lacks details about non-idempotency (idempotentHint=false), potential duplicate handling, required permissions, or any side effects. The description adds minimal context beyond the annotations.

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

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

The description is a single, front-loaded sentence that efficiently states the core function. It is concise but could include more detail without excessive length.

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

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

Given the complexity (3 parameters, no output schema) and numerous sibling tools, the description is insufficient. It does not explain what a knowledge base is, its relationship to bots, or what the return value is. More context is needed to fully understand the tool's role in the system.

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%, so the schema already documents all three parameters. The description does not add any extra meaning or context for the parameters (e.g., what rootInstruction does). Baseline score of 3 is appropriate as the description provides no additional parameter insight.

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

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

The description clearly states the tool's purpose: creating a knowledge base to store and organize information, documents, and entries. It uses a specific verb ('Create') and resource ('knowledge base'), and effectively distinguishes it from sibling tools like neuron_get_knowledge_base (read) and neuron_delete_knowledge_base (delete).

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

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

The description provides no guidance on when to use this tool versus alternatives such as neuron_attach_knowledge_base or neuron_create_kb_entry. It does not mention prerequisites, required roles, or scenarios where creating a new knowledge base is appropriate compared to other operations.

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

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

Annotations already indicate this is a write operation (readOnlyHint=false). The description adds context about config structure and the stream type being 'fed by the ingest endpoint,' but it does not disclose potential side effects like external network calls or authentication requirements (e.g., DeepAPI) that are only mentioned in the schema, not the description. It provides some behavioral context beyond annotations, but not rich detail.

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 dense paragraph, but every segment is informative. It front-loads the action ('Create a lead source') then efficiently enumerates config types and scheduling. While it is not visually structured, it avoids fluff and packs essential information into a compact form. Slightly hard to parse due to density, but appropriately sized for the tool's complexity.

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

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

The tool is complex: 7 parameters, nested objects, multiple type-dependent configs, and scheduling. The description covers the config variants, scheduling, and notes the stream type's special ingestion mechanism. It does not mention return values, but no output schema exists, so that is not a gap. Missing details like toolId references for tool_output and exact csv rows structure are minor given the overall completeness.

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

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

Schema description coverage is only 14%, with most parameters lacking descriptions. The tool description compensates significantly by specifying the shape of `config` for each type (e.g., web_scrape {url|urls[]}) and the structure of `schedule` (cron {time,days?} / interval {everyMinutes} / once {runAt}). This adds critical semantic meaning beyond the bare schema. However, it does not define nested fields like `rows[]` or `args` fully, so it is not exhaustive.

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 'Create a lead source,' which is a specific verb plus resource, clearly indicating the tool's purpose. It further elaborates on multiple source types (text_paste, web_scrape, document, etc.), distinguishing it from sibling tools like neuron_list_lead_sources or neuron_run_lead_source. The purpose is unambiguous and well-scoped.

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

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

The description provides clear context on how to configure different source types and schedule options, e.g., 'Set scheduleKind cron/interval/once for recurring.' It implicitly says to use this tool when creating any kind of lead source. However, it does not explicitly name alternative tools or state when not to use it, so it lacks the explicit pointers seen in the highest benchmark examples.

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

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

Annotations already indicate a write operation (readOnlyHint=false) and non-destructive action (destructiveHint=false). The description adds the valuable context of requiring a connected Baileys session, which is beyond what annotations provide. No contradictions.

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

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

Two sentences, no wasted words. The first sentence states the core action, the second adds an essential prerequisite. Information is front-loaded and efficient.

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

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

For a creation tool without an output schema, the description lacks information about return values (e.g., created newsletter ID) and potential error conditions. However, it adequately covers the core action and prerequisite. The high schema coverage partially compensates.

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%, so the baseline is 3. The description does not repeat parameter details but adds context for channelId via the session requirement. However, it provides no extra semantics for name or description 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 clearly states 'Create a new WhatsApp Channel newsletter for one-way broadcast updates,' specifying a precise verb (Create) and resource (WhatsApp Channel newsletter). It distinguishes this from sibling tools like neuron_create_broadcast and neuron_create_channel by emphasizing the 'one-way broadcast' nature.

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

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

The description provides a key prerequisite: 'Requires a connected Baileys session on the specified channel.' This guides when to use the tool, but it does not explicitly suggest alternatives or exclusions, though these are partially implied by the sibling list.

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

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

Annotations already indicate a write operation (readOnlyHint=false). The description adds that it sends HTTP POST requests and lists event types, but does not cover idempotency, retry behavior, or error handling. Provides some value beyond annotations but significant gaps remain.

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, front-loaded with the primary action and resource. No filler words. Each sentence adds value.

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

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

No output schema, and the description does not mention return value (e.g., webhook ID, status). Also missing details about webhook verification, activation, or delivery guarantees. For a 5-parameter creation tool, this is incomplete.

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 5 parameters have schema descriptions (100% coverage). The description reiterates the supported events already present in the schema enum but adds no new meaning. Baseline 3 is appropriate since schema already carries the burden.

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

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

The description clearly states the tool creates an outbound webhook that sends HTTP POST requests for specified bot events. It lists supported event types, distinguishing it from related tools like neuron_create_webhook (likely inbound) and neuron_update_outbound_webhook.

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?

No guidance on when to use this tool versus alternatives (e.g., neuron_create_webhook, neuron_update_outbound_webhook). No when-not-to-use or prerequisite conditions are mentioned.

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

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

Annotations indicate readOnlyHint=false, which matches the creation behavior. The description adds context about credential format but does not disclose edge cases or potential side effects beyond creation. No contradictions with annotations.

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

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

The description is concise with three front-loaded sentences: main action, supported platforms, and credential details. 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?

The description covers platform and credentials well but omits explanation for optional parameters (label, username). No output schema or return value description, which could help an agent understand what is produced.

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%, but the description adds value by specifying that credentials should be 'full session JSON' and listing expected fields (account, cookies, headers, tokens). This goes beyond the schema description.

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

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

The description clearly states the verb 'Create', the resource 'social media channel', and specifies supported platforms ('Instagram and Twitter/X'). This distinguishes it from sibling tools like 'neuron_create_channel' (likely generic) and others.

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 social media channel creation and lists supported platforms, but does not explicitly state when to use this tool versus alternatives like 'neuron_create_channel' or when not to use it.

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?

Beyond the annotations (all false, indicating a write operation that is not idempotent), the description adds valuable behavioral context: 'Sends are always screened against Do-Not-Contact, a per-run cap, and a no-repeat window.' This discloses safety guardrails and how the bot executes the instruction with its tools. No contradiction with annotations.

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

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

The description is two sentences, front-loaded with the core verb+resource. The first sentence states the purpose, and the second adds meaningful examples and safety constraints. No filler or repetition of schema information.

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

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

Given the tool's complexity (8 parameters, nested objects, and no output schema), the description covers the essential concept and safety behavior. It does not mention return values, but for a create operation with comprehensive schema documentation, this is not a critical gap. The description is sufficiently complete for an agent to understand the tool's role.

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 has 100% parameter description coverage, so the baseline is 3. The description adds meaning by clarifying that 'instruction' is a self-contained, natural-language directive and gives concrete examples of what it can include. This extra context helps agents construct valid instructions without relying solely on the schema.

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

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

The description opens with 'Create a scheduled autonomous task for a bot,' which identifies the specific action (create), resource (task), and scope (scheduled, autonomous, for a bot). It clearly distinguishes this from sibling tools like run_task or update_task. The additional detail about natural-language instructions reinforces what the tool does without ambiguity.

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

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

The description provides clear context for when to use this tool: it is for scheduling autonomous bot tasks, with examples of instructions such as 'find stale conversations' and 'message contacts.' It does not explicitly name alternatives or exclusions, but the context sufficiently differentiates it from one-off send tools or manual run 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 indicate readOnlyHint=false and openWorldHint=true. The description adds that it creates a tool for bot use, but does not disclose any side effects, limits, or lifecycle implications beyond what annotations already suggest.

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 that clearly conveys the core purpose. It is front-loaded with the action and resource, making it efficient and easy to parse.

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

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

The tool has complex nested config and 8 parameters, yet the description provides no information about lifecycle, testing, or how the created tool integrates with the bot. It is insufficient for an agent to fully understand the tool's role in the workflow.

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

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

With 100% schema coverage, all parameters are described in the schema. The description adds no additional meaning or context about parameters, so baseline score 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 clearly states it creates a custom API tool for a bot to fetch external data or trigger actions. It uses a specific verb and resource, and distinguishes from other 'create' tools by specifying 'tool' as the resource.

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

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

No explicit guidance on when to use this tool versus alternatives like update_tool or test_tool. It does not mention when not to use it or provide context for selecting this tool over built-in 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 indicate writable (readOnlyHint=false), non-idempotent, non-destructive. The description adds that it triggers bot actions, which is consistent. However, it omits details like required permissions, whether creation is synchronous, or any side effects.

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, no filler, directly states the tool's purpose. Efficient and well-structured.

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

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

With 6 parameters (2 required) and no output schema, the description alone is insufficient for an agent to fully understand what the tool returns (e.g., webhook ID, URL). It relies entirely on the schema and annotations, and lacks usage context or error scenario hints.

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

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

Schema description coverage is 100%, so the schema already documents all 6 parameters. The description does not add any further explanation or context for the parameters 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 clearly states the verb 'register', the resource 'inbound webhook endpoint', and the context 'triggers bot actions when called by an external service'. It distinguishes this from sibling tools like 'neuron_create_outbound_webhook' by specifying 'inbound'.

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 creating inbound webhooks but does not explicitly state when to use it vs alternatives (e.g., outbound webhooks or update tools). No prerequisites or conditions are mentioned.

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

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

Annotations already indicate destructiveness (destructiveHint: true). The description adds the insight that deletion is permanent and restricted to draft status, providing useful context beyond annotations. No side effects or authorization details are mentioned, but the destructiveness is well 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?

The description consists of two straightforward sentences with no unnecessary words. It front-loads the key action and constraint, making it easy to parse quickly.

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

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

Given the simple input schema (one parameter) and no output schema, the description fully explains what the tool does and its precondition. It provides all necessary context for correct invocation without requiring additional details.

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?

There is only one parameter (adRequestId) and its schema description is already comprehensive ('Unique identifier (UUID) of the draft ad request to delete'), achieving 100% coverage. The tool description adds no extra semantic value beyond what the schema provides. Baseline score of 3 is appropriate.

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

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

The description clearly states the action ('permanently delete'), the resource ('draft ad request'), and a key constraint ('only draft status'). This distinguishes it from sibling deletion tools and makes the tool's purpose unambiguous.

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

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

The description specifies the condition under which the tool should be used (only draft ad requests), but it does not explicitly mention when not to use it or suggest alternatives like updating or pausing non-draft requests. Still, the condition is clear enough for correct 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 adds the 'cannot be undone' emphasis, but annotations already provide destructiveHint=true and readOnlyHint=false. The behavior is consistent with annotations, so the description adds minimal additional value beyond reinforcing permanence.

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, concise sentence with no fluff. It efficiently conveys the essential information.

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

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

For a simple delete operation with one parameter and no output schema, the description covers the purpose, required input, and consequence (irreversibility). No critical information is missing.

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

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

Schema coverage is 100% with a clear description of the 'id' parameter. The tool description adds no extra meaning beyond 'by its ID', so baseline score of 3 is appropriate.

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

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

The description clearly states the action 'Permanently delete a blog post by its ID' with specific verb and resource, distinguishing it from sibling tools like create, update, get, list, and publish blog posts.

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 permanent removal of a blog post, and the mention 'cannot be undone' warns of irreversibility. However, it lacks explicit when-not-to-use guidance or alternatives.

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 destructiveHint=true and idempotentHint=true. The description adds critical details: the deletion is permanent, affects all associated data, and cannot be undone. This provides behavioral context beyond the annotations. No contradictions with annotations.

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

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

The description is two concise sentences (14 words) that front-load the action and scope. Every word adds value, with no unnecessary information.

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

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

Given the simple single-parameter schema and annotations, the description covers the essential behavioral aspects. It could mention prerequisites (e.g., bot must exist) or return behavior, but is mostly complete for a delete action.

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 fully describes the single 'id' parameter with 100% coverage. The description does not add further parameter semantics, so a baseline score of 3 is appropriate.

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

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

The description clearly states the action ('Permanently delete a bot') and the resource ('bot'), distinguishing it from sibling tools like neuron_pause_bot or neuron_update_bot. It also specifies the scope ('all its associated data'), making the purpose unambiguous.

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

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

The description implicitly indicates when to use this tool (when permanent deletion is desired) but does not provide explicit guidance on when not to use it or suggest alternatives (e.g., pausing instead of deleting). Given the many sibling tools, more explicit guidance would be helpful.

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

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

Annotations already indicate destructiveHint=true and idempotentHint=true. The description adds context about deleting recipient data and emphasizes irreversibility, which provides modest additional behavioral insight beyond the annotations.

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

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

The description is extremely concise with two front-loaded sentences. Every word serves a purpose, and it communicates the core functionality and permanence without any 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 simple delete tool with one parameter, the description adequately covers the action, scope, and irreversibility. It does not require output schema explanation, and the context provided is sufficient for the agent to understand the tool's effect.

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

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

With 100% schema description coverage, the schema already documents the single parameter 'id' as a UUID. The tool description does not add any extra meaning or context about the parameter, meeting the baseline expectation.

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 (permanently delete a broadcast) and the scope (includes recipient data). It distinguishes itself from sibling tools like neuron_create_broadcast, neuron_get_broadcast, and other delete tools by specifying the resource type.

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

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

The description does not provide guidance on when to use this tool versus alternatives. It lacks prerequisites, context for selection, or explicit exclusions, leaving the agent to infer usage solely from the name and the minimal description.

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

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

The description reinforces the destructive nature (permanent delete), which aligns with the destructiveHint annotation. It adds the status constraint (draft only), providing additional context beyond annotations. No contradiction.

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, front-loaded with the action and condition, no unnecessary words.

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

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

Given one parameter, no output schema, and clear annotations, the description provides all necessary context: precondition (draft status), effect (permanent deletion), and parameter source (id). Complete for the tool's 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?

The single parameter 'id' is fully documented in the schema with a description that matches the tool's purpose. Schema coverage is 100%, so the description does not need to add more, but it does not add extraneous info.

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: permanently delete a campaign, with a specific condition (draft status). It distinguishes from other delete tools by specifying the resource type and the allowed status.

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

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

Explicitly states when to use (draft campaigns) and when not (active/funded). This guides the agent to check campaign status before invoking, distinguishing it from pause or stop 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 destructiveHint=true, and the description adds the detail that active sessions are disconnected and the action is irreversible. This complements the annotations well. However, it does not disclose any required permissions or impact on related entities (e.g., bots assigned to the channel).

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, each essential and front-loaded. No redundant or vague phrasing. The warning about irreversibility is impactful and efficiently placed.

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 destructive operation with one parameter and no output schema, the description covers the key aspects: what is deleted, the irreversible nature, and the side effect on sessions. It could be improved by mentioning how to retrieve the channel ID or that the channel must exist, but overall it is 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 coverage is 100% and the schema already describes the single parameter id as 'Unique identifier (UUID) of the channel to delete.' The description adds no additional meaning beyond the schema, so baseline score of 3 is appropriate.

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

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

The description clearly states the action ('permanently delete'), the resource ('WhatsApp channel'), and includes a specific side effect ('disconnect any active sessions'). This effectively distinguishes it from sibling delete tools like neuron_delete_social_channel or neuron_delete_bot.

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 for permanent removal but does not explicitly state when to avoid it (e.g., if only temporary disconnection is needed) or reference alternatives like neuron_stop_channel_session. The 'cannot be undone' warning is helpful but insufficient 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?

Description adds context beyond annotations: 'permanent' and 'cannot be undone', and 'removes from all contact lists'. Annotations already indicate destructiveHint=true, so the description reinforces without contradicting.

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, front-loaded sentences with no unnecessary words. Every sentence provides key information.

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

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

For a simple deletion operation with one parameter and no output schema, the description adequately covers all needed context: action, scope, and irreversibility.

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% with a clear description for the 'id' parameter. Description does not add additional semantic value beyond what the schema provides.

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

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

Description clearly states the verb 'delete', the resource 'contact', and scope 'removes from all contact lists'. Distinguishes from siblings like neuron_block_contact and neuron_remove_from_contact_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?

Implies severity ('cannot be undone') but does not explicitly state when to use vs alternatives such as blocking or removing from a list. No exclusions or alternative tool names 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?

Description adds 'Permanently delete' and the exclusion for system-protected lists, providing context beyond annotations. However, it lacks details on permissions, confirmation, or error handling. Annotations already indicate destructiveHint=true, so the description's added value is moderate.

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, immediately states the action and a key constraint. No fluff, every word adds value.

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

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

Simple tool with one parameter, but lacks output description (e.g., success confirmation, error responses). The description is adequate but could be more complete with typical return values.

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 covers 100% of parameter description; the description adds no extra meaning beyond 'idOrSlug' being a UUID or slug. Baseline score of 3 is appropriate as schema does the heavy lifting.

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

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

Clearly states the tool deletes a contact list, with specific verb and resource. Distinguishes itself by mentioning system-protected lists cannot be deleted, differentiating from other delete tools for other 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?

No guidance on when to use this tool vs alternatives. Does not mention prerequisites, context, or scenarios where this tool is appropriate versus other list operations like update or merge.

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 destructiveHint=true and idempotentHint=true. The description adds only 'permanently delete', which aligns but doesn't provide additional behavioral context like error handling or behavior if entry doesn't 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 a single, front-loaded sentence with no wasted words.

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

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

For a simple two-parameter tool with good annotations, the description is sufficient. It could mention idempotency or error handling, but these are not critical given the annotations.

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

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

Schema coverage is 100% with both parameters described. The description does not add any further meaning beyond what the schema provides, 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 (delete), resource (knowledge base entry), and scope (specific entry). It distinguishes from sibling tools like neuron_delete_knowledge_base (different resource) and neuron_update_kb_entry (update vs delete).

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?

No explicit guidance on when to use this tool vs alternatives. The description implies usage for deletion but doesn't provide context like prerequisites, reversibility, or when not to use it among many delete siblings.

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

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

Annotations already indicate destructive and idempotent behavior. The description adds that deletion is permanent and cascades to associated entries and documents, providing useful context beyond annotations.

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

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

The description is a single, concise sentence front-loaded with the action and object, containing no unnecessary 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 deletion tool with one parameter and no output schema, the description covers the essential behavioral effect and resource scope completely.

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% with a clear description for the 'id' parameter. The tool description adds no additional semantic value beyond what the schema provides.

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

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

The description uses a specific verb 'delete' and identifies the resource 'knowledge base', further clarifying scope with 'all its associated entries and documents'. It clearly distinguishes from sibling delete tools.

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

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

The description implies use when permanent deletion is desired, but no explicit when-not-to-use or alternative tools (e.g., detach_knowledge_base) are mentioned.

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

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

Annotations already provide destructiveHint=true; the description adds 'cannot be undone' which is consistent but doesn't elaborate on side effects like permissions or visibility to other users.

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 that effectively communicate the core purpose and key behavioral trait (permanence). No extraneous information.

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

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

Simple tool with clear input schema and annotations; description adequately covers the essential behavior for an agent to decide invocation. Could mention that the user must own the message or have permissions, but not critical.

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?

Both parameters have descriptions in the schema (100% coverage). Description adds no additional meaning beyond schema 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 clearly states the action (permanently delete), the target (specific message from a conversation), and emphasizes irreversibility. It distinguishes from sibling edit and forward 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?

No explicit guidance on when to use this tool versus alternatives like edit_message or simply hiding messages. No mention of prerequisites or when not to 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?

The description reinforces the destructiveHint annotation by stating the action is permanent and cannot be undone. It adds a small detail about removal from WhatsApp but does not significantly extend beyond the annotation.

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 concise sentence that immediately states the purpose and key trait (permanence). It is front-loaded and contains no unnecessary 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 deletion tool with one required parameter and no output schema, the description adequately covers the essential information: what it deletes and that it is irreversible.

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

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

The input schema covers the single parameter 'id' with a clear description. The tool description adds no additional parameter semantics, so the baseline score of 3 is appropriate given 100% 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?