stream

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

The description adds meaningful behavior beyond the readOnlyHint annotation by stating this is a GET call to /api/v2/app and that it serves as a credential check. It also explains what the agent can learn from it (available channel types), which supports correct expectations. 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?

Two concise sentences deliver purpose, use case, and endpoint with no filler. The information is front-loaded and every phrase earns its place.

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

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

For a zero-parameter, read-only settings-fetching tool with a safety annotation already present, the description covers what the tool does, why to call it, and the endpoint. Nothing essential is missing for correct invocation.

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

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

The tool has zero parameters, so there are no parameter semantics to document; the baseline of 4 applies. The description's clarity about the endpoint and purpose fully compensates for any absence of parameter-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 states a specific verb ('Fetch'), a clear resource ('Stream app's settings and configured channel types'), and distinguishes this tool from sibling tools that operate on channels, messages, or threads. The phrase 'Good first call' reinforces its app-level scope, making it unmistakable.

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 positions this as the first call to confirm credentials and discover available channel types, giving clear context for when to invoke it. It does not explicitly list alternatives or exclusions, but the guidance is specific enough for an agent to select it appropriately.

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

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

The description discloses a meaningful side effect ('may be created empty'), which would otherwise be good behavioral transparency. However, this directly contradicts the readOnlyHint=true annotation because the endpoint can create a channel. Per the rubric, a contradiction with annotations forces a score of 1.

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

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

The core purpose is front-loaded in one sentence, and the behavioral caveat is compact and high-value. The optional API endpoint line adds useful reference detail without padding. There is no filler or repetition.

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

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

For a relatively simple 3-parameter tool with no output schema, the description gives a reasonable high-level idea of the return content: channel state and recent messages. It is only minimally complete because the exact return shape is unstated and the read-only conflict leaves uncertainty about side effects.

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

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

Schema description coverage is 100%, so the baseline is 3. The description adds no extra parameter-level semantics beyond the tool-level summary, but it does not need to because type, id, and messages_limit are already well documented 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 states a specific verb ('Fetch'), a single target resource ('a single channel's state'), and the specific payload ('config, members' and 'most recent messages'). This clearly distinguishes it from sibling tools like stream_query_channels (bulk listing) and stream_get_message (single message).

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

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

There is no explicit guidance on when to use this tool versus alternatives such as stream_query_channels or stream_get_message. No conditions, exclusions, or alternative tool names are given. The get-or-create note is a behavioral caveat, not a usage routing rule.

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

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

The annotations already declare readOnlyHint=true, so the safety profile is covered. The description adds the HTTP GET method and endpoint, which reinforces idempotence, but it does not disclose additional behavioral details such as error behavior or soft-deletion handling; that is left to the show_deleted parameter.

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 core purpose and immediately provides the endpoint. There is no redundant wording or filler.

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

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

For a simple read-only fetch with fully documented parameters and a readOnlyHint annotation, the description provides the necessary endpoint and intent. It does not describe the return payload, but no output schema exists and the tool's behavior is simple enough that this is a minor gap.

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

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

Schema description coverage is 100%, so both parameters (id and show_deleted) are already documented in the schema. The description does not add meaning beyond restating that a single message is fetched by ID, which is the baseline when the schema carries the parameter documentation burden.

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

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

The description states a specific action ('Fetch a single message by its id') and names the resource and identifier requirement. It clearly distinguishes this from sibling tools like stream_search_messages or stream_get_replies by emphasizing a single message fetch by ID.

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

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

The phrase 'by its id' implies the tool should be used when the caller already has a message ID and needs that specific message. However, there is no explicit when-to-use or when-not-to-use guidance, and no alternatives are named, so it does not fully support selection among 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 provide readOnlyHint=true, and the description's "List" plus GET method is consistent with that. It adds the concrete endpoint, but does not disclose additional behavior such as pagination semantics, ordering, or error conditions; this is adequate but not rich.

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

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

Two short, front-loaded sentences with no filler. The first states the operation, and the second supplies the exact endpoint, earning its place as implementation context.

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 list operation, required id is clear, optional limit/offset are in the schema, and the readOnly annotation covers side-effect expectations. The main gap is that no output shape is described and no output schema exists, but the tool's purpose is otherwise self-contained.

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 id, limit, and offset are already documented. The description adds no parameter-level meaning beyond echoing the {id} path placeholder.

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

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

The description states a specific action and resource: "List the reactions on a message," reinforced by the GET endpoint. It is clear what the tool does, but it does not explicitly contrast with sibling tools such as stream_get_message or stream_send_reaction.

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: it should be used when reactions on a message are needed. There is no explicit when-to-use/when-not-to-use guidance or mention of alternatives, so an agent must infer the boundary against sibling tools.

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

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

The readOnlyHint annotation already signals a safe read operation, and the description's GET/fetch language is consistent with it. The description adds the endpoint but does not disclose response shape, pagination behavior, or edge cases; for a simple read-only tool this is adequate but not rich.

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

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

The description is two compact sentences: the first states the purpose and key input, and the second provides the endpoint. There is no filler, redundancy, or unnecessary detail.

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

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

For a low-complexity read-only fetch, the schema covers both parameters, annotations cover safety, and the description states the resource and endpoint. It leaves response format and pagination implicit, but these are not essential for correctly selecting and invoking the tool.

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

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

Schema description coverage is 100%, with both parent_id and limit already documented, including limit's default and maximum. The description only restates parent_id and adds no semantic information 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+resource ('Fetch the reply messages in a thread') and identifies the required key ('parent message id'). The endpoint makes the target resource unambiguous and distinguishes it from siblings like stream_get_message, stream_get_reactions, and stream_query_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 clearly indicates the context for use: given a parent message id, fetch its thread replies. However, it does not explicitly state when not to use this tool or name alternatives, so usage guidance is mostly implied by the name and sibling set.

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

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

The readOnlyHint annotation already communicates that this is a non-destructive read, and the description's 'Fetch' and GET endpoint reinforce that without contradicting it. The description adds the endpoint and scope but does not disclose other behavioral context such as authentication requirements, rate limits, or how results are organized beyond the counts already named.

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

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

The description is two short sentences with no filler. The core function is front-loaded, and the second sentence adds the exact HTTP endpoint, so every part 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 one-parameter, read-only tool without an output schema, the description supplies enough to call it correctly: what counts are returned (total and per-channel unread message/mention counts), the user scope, and the API path. No critical context appears missing for an agent selecting or invoking the tool.

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

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

With 100% schema description coverage, the schema already documents user_id ('User id to fetch unread counts for'). The description's 'for one user' merely restates this parameter's meaning and adds no format, interpretation, or prerequisite 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 names a specific verb ('Fetch') and a concrete resource ('total and per-channel unread message/mention counts for one user'), which clearly distinguishes this from siblings that get apps, channels, messages, reactions, or replies. It also supplies the API endpoint, so an agent knows exactly what resource is being read.

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 only implied: the description says the tool fetches unread counts, so an agent can infer it is for that need. However, it does not state when to prefer it over sibling tools or mention any exclusions or alternatives, leaving the decision to inference.

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

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

The readOnlyHint annotation already establishes that this is a safe read operation. The description adds useful behavioral context beyond that by noting it returns channels with recent state and by giving the exact endpoint, POST /api/v2/chat/channels. It stops short of describing pagination or response shape, but the annotation lowers the bar and this is meaningful extra context.

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

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

The description is compact and front-loaded with the core purpose, followed by a useful example and a return-value note. Every sentence earns its place, and the endpoint line is a practical bonus without padding.

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 list tool with well-described optional parameters, the description covers the essential purpose, filter semantics, return gist, and endpoint. There is no output schema, so a bit more detail on the returned channel representation could help, but the schema and examples make it adequate for a competent 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 description coverage is 100%, so the schema already documents all five parameters and their defaults; the baseline of 3 applies. The description's filter examples add clarity but duplicate the filter parameter's own schema description rather than introducing new semantic information.

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

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

The description opens with a specific verb-resource pair, 'List/filter channels,' and identifies the distinguishing mechanism (a Stream query filter) with two concrete examples. This makes the tool immediately distinguishable from siblings like get_channel (single-channel retrieval) and query_users/query_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?

Usage is implied by 'List/filter channels by a Stream query filter,' but the description never states when to prefer this over alternatives such as stream_get_channel or stream_query_threads. No exclusions or when-not guidance is provided, though the intended use case is reasonably inferable.

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

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

The readOnlyHint annotation already establishes safety, and the description adds useful behavioral context: it is a GET request, scoped to one channel, with an optional filter. It does not describe pagination or return structure, but for a read-only list tool this is sufficient without an output schema.

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

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

Three compact sentences deliver the core action, required parameters, an example, and the endpoint with no filler. The main purpose is front-loaded, and every sentence earns its place.

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

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

The input schema documents all six parameters, annotations cover the read-only safety profile, and the description adds the endpoint and a filter example. For a straightforward channel-member listing tool, the missing return-shape details are a minor gap rather than a blocking omission.

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

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

Schema coverage is 100%, so the baseline is 3. The description adds value beyond the schema by showing a realistic filter example ({"name":{"$autocomplete":"jo"}}) and emphasizing that type and id are required, which helps an agent form valid calls quickly.

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

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

The description opens with 'List/filter the members of one channel,' giving a specific verb, resource, and scope that distinguishes it from sibling tools like stream_query_channels or stream_query_users. The 'one channel' qualifier makes the tool's targeting unambiguous.

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

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

It clearly states the required inputs ('channel type + id'), notes the optional member filter, and gives the HTTP endpoint. It does not explicitly name sibling alternatives or exclusion conditions, but the context makes it evident when this tool should be selected.

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

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

The readOnlyHint annotation already signals this is a read-only operation. The description adds that thread read-state is user-scoped and provides the endpoint, but it does not disclose return shape, pagination, authentication needs, or other behavioral details beyond what annotations already convey.

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

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

Two sentences with zero filler: definition, server-side usage note, and endpoint. The most important information is front-loaded.

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

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

For a read-only query tool with all parameters documented in the schema, this is nearly complete. It includes the endpoint, the key user-scoping caveat, and a terse definition. It could be slightly stronger with explicit sibling routing or a note about return values, but nothing essential is missing.

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

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

Schema description coverage is 100%, so baseline is 3. The description's note about user_id scoping read-state repeats what the schema already says ('scope thread participation/read-state to'), adding only the 'server-side calls should pass' nuance. No substantial new parameter meaning is provided.

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

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

The description states a specific action and resource: 'List threads' and clarifies that threads are 'messages with replies'. This makes the tool's purpose clear and distinguishes it from message/channel/user queries, though it does not explicitly name or contrast a sibling tool.

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

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

It provides clear contextual guidance: server-side calls should include user_id to scope thread read-state to that user, and it gives the endpoint POST /api/v2/chat/threads. It does not explicitly discuss alternatives or when not to use this tool, but the context is clear enough 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?

The readOnlyHint annotation already covers the safety profile. The description adds the endpoint and filter examples, but does not disclose behavior such as pagination limits or response format. Given the annotation coverage, this is acceptable but not rich.

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

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

The description is one efficient sentence plus a concrete filter example and endpoint. Every element earns its place and the core purpose is front-loaded.

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

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

The tool has four parameters and no output schema, so the description could do more to explain return shape or pagination behavior. The endpoint and examples help, but explicit guidance on when to prefer this over sibling query tools is missing.

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

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

Schema description coverage is 100%, so the parameters are already well-documented. The description provides a filter example that mirrors the schema's own examples but adds no new meaning for sort, limit, or offset beyond what the schema states.

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-resource pair ('List/filter users') and adds a concrete endpoint, so an agent can tell this is a user-query tool. It doesn't explicitly distinguish itself from siblings like stream_query_channels, but 'users' makes the target resource 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 clearly implies this tool is for retrieving/filtering users by giving examples of filter conditions and the GET endpoint. However, it does not explicitly state when not to use it or name alternative tools, leaving some inference to the agent.

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

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

Annotations already declare readOnlyHint=true, and the description adds the GET method and cross-channel search scope. This adds some behavioral context without contradicting the annotations, but it does not disclose pagination behavior, rate limits, or what happens with malformed filter combinations.

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

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

The description is two sentences with no filler. The action and scope are front-loaded, and the parameter-combination guidance and endpoint are packed efficiently into the second sentence.

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

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

For a search tool with six parameters, nested objects, and no output schema, the description covers the essential invocation rules and provides examples. It does not describe the result shape or pagination cursor flow, but the input schema already documents limit, sort, and next, so the remaining gap is minor.

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

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

The schema already documents all six parameters with 100% coverage, but the description adds value by explaining the OR-exclusivity between query and message_filter and by giving concrete JSON examples for both filter and message_filter. This helps an agent select the correct parameter combination beyond what the schema alone offers.

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

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

The description states a specific verb and resource: 'Search messages across channels.' It also names the endpoint, making clear this is a message-search operation and distinguishing it from siblings like stream_get_message, stream_query_channels, and stream_send_message.

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 concrete guidance on how to combine arguments, explicitly stating that the caller must provide a channel filter plus either query or message_filter. However, it does not contrast this tool with alternatives such as stream_get_message for retrieving a single message, so when-to-use-versus-sibling guidance is only implied.

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

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

Annotations already provide destructiveHint=true, and the description reinforces this with the WRITE warning. It adds the endpoint and the existing-user prerequisite, but the prerequisite is already present in the schema's user_id description. There is little new behavioral detail such as side effects, response behavior, or 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?

The description is a single front-loaded sentence with the WRITE disclaimer and endpoint, which is efficient. It repeats 'WRITE' from the title, creating a small redundancy, but otherwise contains no filler.

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

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

For a straightforward message-posting call, the description and schema provide enough to invoke it correctly. However, there is no output schema and the description says nothing about the expected response, error cases, or side effects, leaving some operational uncertainty for the 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?

The schema covers 100% of parameters with meaningful descriptions, so the description does not need to compensate. It does not add significant meaning beyond what the schema already states, earning the baseline 3 for well-covered schemas.

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 specific action: 'post a new message to a channel, attributed to user_id.' It also names the resource and endpoint, making it unambiguous. This distinguishes it from siblings like stream_send_reaction because it targets message creation, not 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?

The WRITE label and 'post a new message' wording imply this is the tool to use for sending messages, but the description never explicitly says when not to use it or names alternatives among the read/query siblings. Usage context is implied rather than stated, leaving the agent to infer routing.

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 provide destructiveHint=true, while the description adds the explicit WRITE warning, the POST endpoint, and the requirement that user_id reference an existing user. This gives useful behavioral context beyond the annotations, without contradicting them.

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

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

The description is a single, well-structured sentence with the critical WRITE warning front-loaded and the endpoint included. Every element earns its place with no unnecessary filler.

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

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

The description, combined with the output-free schema and destructiveHint annotation, provides everything needed to invoke the tool correctly: the operation, target resource, endpoint, required parameters, and the user existence caveat.

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 and their meanings. The description reinforces the user_id requirement and provides reaction examples, but adds no substantial 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 states a specific action ('add a reaction to a message'), identifies the resource (message), and includes the endpoint. This clearly distinguishes it from siblings like stream_send_message and stream_get_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?

The description clearly implies when to use this tool: whenever a reaction needs to be added to a message. It also adds a precondition (user_id must be an existing user), but does not explicitly name alternatives or when-not-to-use scenarios.

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