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

With no annotations, the description discloses key behaviors: low-consequence write (non-destructive), idempotent behavior, and no draft/confirm. This is sufficient for a reaction tool.

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

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

Two sentences, no filler. Critical information is front-loaded. Excellent conciseness.

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 reaction tool, the description covers key behaviors and one parameter. However, missing parameter details for channel/ts and workspace (optional) could lead to incorrect invocation. Output schema exists but not shown.

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

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

Schema coverage is 0%, so description must explain parameters. Only emoji is explained (colon-stripped name). channel and ts receive no explanation, and workspace is omitted. This leaves ambiguity.

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

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

The description explicitly states the action (add) and resource (emoji reaction to a message). It clearly distinguishes from sibling tools like send_message or send_reply_quote by focusing on reactions.

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

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

Provides usage context: explains the emoji format, notes low-consequence write without draft+confirm, and mentions idempotency with soft success on duplicates. Does not explicitly state when not to use, but the guidance is clear enough.

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

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

The description adds the behavioral trait 'idempotent,' which is not in annotations or schema. However, with no annotations provided, it fails to disclose other traits such as whether the operation is destructive or reversible, leaving gaps.

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

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

The description is extremely concise with two short sentences, no redundant information, and a clear front-loaded purpose.

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 and the presence of an output schema, the description covers the basic purpose and key behavioral trait. However, it lacks details on prerequisites, side effects, or differentiation from the 17 sibling tools.

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

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

The single parameter draft_id has 0% schema description coverage, and the tool description provides no additional meaning or context about it (e.g., format, required values, or how to obtain it).

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') and the target resource ('unconfirmed draft'), with the qualifier 'idempotent.' It effectively distinguishes from sibling tools like confirm_send or send_message by focusing on the cancellation of drafts.

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 or avoid this tool. While 'unconfirmed draft' implies a context, there is no comparison with alternatives (e.g., confirm_send) or mention of prerequisites like ownership.

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

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

Without annotations, the description adds behavioral context about dispatch per draft.kind and in-place editing, but omits side effects (e.g., draft state after commit) or error conditions.

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, front-loads the core purpose, and lists variations without 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 an output schema exists, the description covers main behavior and draft variations, but misses prerequisites or error handling for invalid draft_id.

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

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

With 0% schema coverage, the description explains that draft_id refers to a previously-drafted send and implies its use from draft creation, but lacks detail on format or how to obtain it.

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 commits a drafted send and details the dispatch behavior based on draft.kind, differentiating it from siblings like send_message and cancel_draft.

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 after drafting and lists the specific actions, but does not explicitly state when not to use or mention alternatives like cancel_draft.

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

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

No annotations are provided, so the description fully covers behavioral traits: it calls chat.delete, returns ok=True, treats message_not_found as soft success, is low-consequence (no destructive cascade), and mentions audit logging. This goes well beyond what the input schema reveals.

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?

Four sentences, each serving a distinct purpose: action, API details, edge cases, and behavioral context. No filler. Front-loaded with the core purpose.

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, the description covers what the tool does, how it works, edge cases (soft success), and implications. An output schema exists but is not shown; the description already mentions the return value. No gaps given the low complexity.

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

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

Schema coverage is 0%, but the description clarifies required parameters ('channel, ts') and their role in the underlying API call. The optional 'workspace' parameter is not explained, leaving some ambiguity. The description adds value but not comprehensive param-level detail.

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 starts with 'Delete one of your own messages,' which is a clear verb+resource statement. It is distinct from siblings like update_own_message, send_message, etc., because it focuses on deletion of own messages only.

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 states the tool is for deleting your own messages and mentions token/scopes. It implies low-consequence and no draft+confirm, which helps the agent decide to use it directly. However, it does not explicitly contrast with other tools like update_own_message or list 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?

No annotations are provided, so the description carries full burden. It does not disclose any behavioral traits such as whether it is read-only, requires permissions, or has rate limits. Only states 'Get full profile', which is insufficient.

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 brief (one sentence) and front-loaded with the action. However, it lacks necessary details, making it insufficiently informative. No extra fluff, but too tersely written.

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

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

Given the low complexity (2 params, output schema exists but not shown) and absence of annotations, the description is incomplete. It does not explain what 'full profile' entails nor the role of the optional workspace parameter. More context is needed for an agent to use it correctly.

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

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

With schema description coverage at 0%, the description must explain parameters. It only indirectly mentions user_id in the description text but does not explain the workspace parameter or the format of user_id. The schema itself is minimal with no 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 (get full profile) and the resource (user_id with format U... or W...). It distinguishes from sibling tools like list_users or search_users by implying it retrieves a single user's complete profile, not 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?

No guidance on when to use this tool versus alternatives like list_users or search_users. It does not mention prerequisites or scenarios where this is preferred over 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?

Discloses behavior: calls auth.test per workspace, returns success/error, no retries, and meaning of failure. With no annotations, the description fully informs the agent of safety and failure modes.

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-load the purpose and then add necessary behavioral details. Every word serves a purpose—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 zero parameters and presence of an output schema, the description fully covers the tool's operation, failure implications, and references external documentation (SETUP.md). Complete for a healthcheck.

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?

No parameters exist (0 params, 100% schema coverage), so parameter semantics are not needed. Baseline 4 applies as description adds no redundant param detail.

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 'Verify' and resource 'token validity per workspace', clearly distinguishing from sibling tools like list_workspaces or send_message. The purpose is immediately obvious.

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?

States 'Does not retry' and explains failure implies token invalidation, guiding when re-extraction is needed. While not explicitly listing when not to use, the context is sufficient given the tool's specificity.

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

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

With no annotations, the description carries the burden. It explains default types behavior and that limit caps at the API page size. It does not disclose pagination, rate limits, or authentication requirements, which are common for list endpoints.

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 sentences. The first sentence states the core purpose, and the second sentence adds crucial parameter details. Every sentence adds value 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 the output schema exists, return values are not needed. The description covers the main filtering behavior but misses explaining the 'workspace' parameter and pagination details beyond 'caps results at the API page size'. It is adequate but leaves gaps.

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

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

Schema description coverage is 0%, so the description must compensate. It explains the 'types' parameter (comma-separated subset and default) and 'limit' (caps results), but omits any explanation of the 'workspace' parameter, leaving its meaning unclear 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 it lists channels in the workspace, specifying the verb 'list' and resource 'channels'. It hints at filtering by types and limit, but does not explicitly differentiate from sibling tools like search_channels, though the verb implies a full listing vs. search.

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 on when to use it (list all channels) and a hint about default behavior (omitting DMs to keep responses short). However, it lacks explicit when-not-to-use guidance and does not mention alternatives such as search_channels for targeted queries.

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

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

With no annotations, the description carries full burden but only discloses the exclusion of deleted users. Missing details like authentication requirements, rate limits, or mutability.

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 key information. Every word adds value; no wasted 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 3 undocumented parameters and no annotations, the description is insufficient. It omits important context like return format, pagination, and workspace scoping.

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

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

Schema description coverage is 0%. The description only indirectly references the 'include_deleted' parameter through the default behavior. No explanation of 'limit' or 'workspace' parameters.

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

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

The description clearly states the verb 'List' and the resource 'users in the workspace', and adds a key default behavior (excludes deleted). This distinguishes it from sibling search tools, though not explicitly.

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

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

No guidance on when to use this tool versus alternatives like search_users or list_channel. The description does not mention exclusions or context for 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?

No annotations are provided, so the description carries the full burden. It discloses that the response contains a list of redacted profiles, primary alias, and config errors, and explicitly states that tokens never appear. This provides meaningful behavioral context beyond the tool name.

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 first sentence front-loading the core purpose. Every word adds value, with no redundant or 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 tool has no parameters, an output schema exists, and no annotations, the description fully covers the return structure, including redaction and error handling. It is complete for a simple list tool.

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

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

The tool has zero parameters. Description does not need to add parameter details as none exist. The baseline for 0 parameters is 4, and no improvement is necessary.

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

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

The description clearly states the tool lists configured Slack workspaces with auth type and primary status. The verb 'List' and resource 'workspaces' are specific, and it is distinct from sibling tools like list_channels or list_users, which operate on different Slack entities.

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 is for retrieving workspace configuration, but it does not explicitly state when not to use it or mention alternatives. However, given that no other sibling tool lists workspaces, the context is clear enough.

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

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

The description discloses a key behavioral trait: 'Affects unread state across all your linked devices.' This is valuable beyond the annotations (none provided). However, it does not mention reversibility, required permissions, or potential side effects (e.g., notifications). The transparency 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 that are front-loaded with the core purpose. Every word adds value; no fluff. Ideal conciseness for a simple tool.

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 existence of an output schema, the description does not need to detail return values. It explains the main action and ts usage, but leaves out details about the 'channel' parameter format, the optional 'workspace' parameter, and any prerequisites or errors. Adequate but not fully complete.

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

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

With 0% schema description coverage, the description must compensate. It adds meaning for 'ts' by specifying it should be the most recent message ts. For 'channel', the resource is implied. 'workspace' is not explained. Overall, partial but incomplete guidance.

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

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

The description clearly states the verb ('Mark') and resource ('a channel') with a specific parameter ('up to a given message ts'). It distinguishes from sibling tools like read_channel, which likely retrieve messages without modifying unread state. The purpose is 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 guidance on how to set the 'ts' parameter ('Use the ts of the most recent message you've read'), but does not explicitly state when to use this tool over alternatives like read_channel, nor does it mention when not to use it. Some implicit context is present, but it lacks explicit usage boundaries.

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 explicitly discloses the auto-export side effect to the vault, which is critical for an agent to understand. However, with no annotations, the description carries full burden, and it does not mention rate limits, auth needs, or handling of missing channels.

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 short (three sentences) and front-loaded with purpose. It is concise, but some parameter details are missing, which reduces effectiveness. Nonetheless, it avoids verbosity.

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

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

Given 5 parameters and no annotations, the description lacks detail on limit, time filters (latest/oldest), and workspace selection. Even with an output schema, the agent cannot fully understand how to use parameters like latest and oldest without additional context.

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

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

Schema description coverage is 0%, meaning no parameter descriptions in the schema. The description only explains the 'channel' parameter (ID or name). Parameters like limit, latest, oldest, and workspace are not described, leaving their semantics ambiguous (e.g., whether latest/oldest are timestamps or message IDs).

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 'Read recent messages from a channel,' with a specific verb and resource. It differentiates from sibling tools like read_thread (thread-specific) and search_messages (search-oriented) by focusing on reading messages from a channel directly.

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 input format (ID or name) and ordering ('Newest first'), but lacks guidance on when to use this tool vs. alternatives like search_messages for filtering or read_thread for threaded conversations. No exclusions or prerequisites 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?

With no annotations, the description adds value by disclosing that the returned messages list includes the parent as element 0, and explains that channel accepts ID or name. This goes beyond basic 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 very concise with three sentences, front-loading the purpose. 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 4 parameters and an output schema, the description covers purpose, key params, and return format but misses explanation for 'limit' and 'workspace'. Overall adequate but not fully complete.

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

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

Schema description coverage is 0%, so the description must compensate. It explains 'ts' (parent message timestamp) and 'channel' (ID or name), but does not explain 'limit' or 'workspace', leaving 2 of 4 parameters undocumented.

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

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

The description clearly states 'Read a thread's parent message and replies,' specifying the verb and resource. It implicitly distinguishes from sibling tools like read_channel by focusing on threads.

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 reading threads by explaining parameters, but lacks explicit guidance on when to use this tool versus alternatives or any when-not-to-use 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?

No annotations exist, so the description must fully disclose behavior. It states substring matching and case-insensitivity but omits details about default behavior (e.g., empty query), pagination, or result limits. The existence of an output schema helps but isn't referenced.

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 short sentences with no wasted words. It is front-loaded with the core functionality and case-insensitivity trait.

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 three parameters with no coverage in the description, no annotations, and an output schema that isn't explained, the description is incomplete. It fails to inform the agent about parameter roles or search behavior details necessary for correct invocation.

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

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

With 0% schema description coverage, the description adds no meaning to the three parameters (query, types, workspace). It does not explain their purpose, defaults, or allowed values, relying entirely on the schema which may be insufficient for the agent.

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 performs substring matching against channel names and topics, with case-insensitivity. This distinguishes it from sibling tools like list_channels (which lists all channels) and read_channel (single channel retrieval).

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 finding channels by substring, but no explicit when-to-use or when-not-to-use guidance is provided. It does not contrast with alternatives like search_users or search_messages, leaving some ambiguity.

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

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

No annotations provided, so the description carries the full burden. It discloses auth requirements, error behavior (loud error with auth_type), and the channel sugar mechanism. It does not cover pagination or rate limits, but some behavioral context is present.

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

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

The description is concise and well-structured, using bullet-like formatting for query modifiers. Every sentence adds value, and there is no redundancy or fluff.

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

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

Given 6 parameters, 0% schema coverage, no annotations, but an output schema exists, the description covers the most critical parts (query and channel) and auth. It omits details on limit, sort, sort_dir, and workspace, leaving the agent to infer or rely on the 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 description coverage is 0%, so the description must compensate. It explains the `query` parameter with Slack modifiers and the `channel` parameter as sugar. However, parameters like `sort`, `limit`, `sort_dir`, and `workspace` are not described, leaving gaps.

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

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

The description clearly identifies the tool as searching messages with Slack's full-text search. It explains the query syntax and distinguishes from sibling tools like search_channels via explicit channel usage guidance.

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 states when to use and provides critical auth context (requires xoxc/xoxp, not xoxb). It does not explicitly list when not to use alternatives, but the context is sufficient for decision making.

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

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

No annotations are provided, so the description carries full responsibility. It only states the matching fields and substring behavior but omits details like case sensitivity, pagination, performance, or what happens when query is empty. This is a significant gap for a search tool.

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

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

The description is a single, clear sentence with no waste. It is front-loaded with the key action and fields. Could benefit from slightly more structure, but remains 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 an output schema present, return value explanation is unnecessary. However, the tool lacks behavioral details like empty query handling and workspace scope. The description is adequate but leaves some gaps.

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

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

Schema coverage is 0%, so the description must compensate. It explains that 'query' is a substring matched against listed fields, adding value. However, it does not detail the 'workspace' parameter's role or behavior when null. Some meaning is provided, but not complete.

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 that the tool performs substring matching against specific user fields (real_name, display_name, email, name). This distinguishes it from sibling tools like list_users (lists all users) and get_user_profile (fetches a specific user's profile).

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 when you need to find users by partial name or email, but does not explicitly state when not to use it or mention alternatives. Given the sibling tools, the context is clear enough for an agent to infer appropriate 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?

Since no annotations are provided, the description carries full behavioral burden. It discloses that the tool only stages, requires confirm_send to post, returns a draft_id and other fields, drafts expire in 1 hour and can only be confirmed once. This fully communicates the behavioral traits.

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 five sentences, each adding distinct value: staging behavior, return values, expiry, thread usage, and alternative tool. No redundant or irrelevant information. Front-loaded with the key action.

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

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

Given the tool has 4 parameters, an output schema, and no annotations, the description covers the staging workflow, return values, thread usage, and expiration. It doesn't handle error cases (e.g., invalid channel) or permission requirements, but the completeness is high for the stated purpose. The output schema provides return value details, so the description doesn't need to replicate that.

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

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

Schema description coverage is 0%, so the description must compensate. It explains thread_ts is for thread replies and suggests using send_reply_quote for quotes. However, it does not explain workspace (though return mentions 'resolved workspace') or provide details on text and channel, which are somewhat self-explanatory but could be clarified. Partial value added.

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 starts with 'Stage a message send. Does NOT post until confirm_send is called.' This clearly states the action (stage a send) and the resource (message), distinguishing it from sibling tools like confirm_send. It also differentiates from send_reply_quote for quote replies.

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

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

The description provides explicit guidance for thread replies (set thread_ts) and redirects to send_reply_quote for quote replies. It implies the two-phase workflow (stage then confirm), but doesn't explicitly state when not to use this tool (e.g., for quick sends without staging). However, the context is clear enough for an agent.

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

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

With no annotations, the description carries full burden. It reveals the two-step draft+confirm process and the user-facing nesting behavior, but omits details on draft lifecycle, expiration, rate limits, or authorization 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 exceptionally concise: two sentences front-loaded with the core purpose and followed by behavioral context and user-facing effect. No extraneous 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?

Despite having an output schema (so return values are covered elsewhere), the description lacks details on parameter formats (e.g., timestamp syntax) and the confirmation step. For a 4-parameter tool with 3 required and no annotation, it is somewhat sparse but covers the essential 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?

Schema coverage is 0%, requiring description to compensate. The description explains 'target_ts' as the target message timestamp and implies threading, but leaves other parameters (text, channel, workspace) without explanation. The workspace parameter's optional/nullable nature and format expectations are not addressed.

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 stages a reply threaded under a target message timestamp, using specific verb 'Stage a reply' and resource 'thread under target_ts'. It distinguishes from the sibling 'send_message' by focusing on replies without introducing 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 references 'Same draft+confirm semantics as send_message,' guiding the agent on the usage pattern. However, it lacks explicit when-not-to-use instructions or alternatives to other sibling tools like 'add_reaction' or 'delete_own_message'.

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

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

With no annotations, the description fully bears this burden. It discloses that the tool does not update until confirm_send is called, fetches current text for a visual diff, returns a preview with before/after, states that drafts expire after 1 hour, and can only be confirmed once—very transparent.

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

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

The description is multi-paragraph but each sentence contributes unique information. It is front-loaded with the key caveat about confirm_send. Could be slightly more concise, but overall well-structured.

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

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

Given the tool's complexity (two-phase update, draft expiration, preview), the description is comprehensive. It covers return values (draft_id, preview, etc.), and the presence of an output schema further supports completeness for return types.

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

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

Schema coverage is 0%, so the description must compensate. It mentions channel, ts, text, and workspace (optional) but does not provide detailed syntax or constraints (e.g., ts format). This adds some value but not enough to fully cover missing schema descriptions.

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

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

The description clearly states the tool's purpose: 'Stage an edit to one of your own messages' and emphasizes it does NOT update until confirm_send is called, distinguishing it from sibling tools like send_message and confirm_send.

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 explains the two-phase workflow (stage then confirm) and mentions that after confirm_send the message is edited via chat.update, providing context. It does not explicitly list when not to use, but the sibling list includes alternatives like delete_own_message, so the guidance is adequate.

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