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

Since no annotations are provided, the description must convey behavioral traits. It discloses that the operation is a public write ('Writes publicly') and advises confirmation, which is a meaningful caution. It also explains the correct format for `post_id` to avoid errors. This goes beyond a simple statement of the action, though it doesn't mention reversibility or other 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 sentences with no unnecessary words. The purpose is front-loaded, followed by the parameter clarification and then the behavioral caution. The structure 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 two required parameters and no output schema, the description covers the purpose, the critical parameter nuance, and the public write nature. It could optionally mention response format, but that's not essential given no output schema. The description is sufficiently complete for an agent to invoke 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?

With 0% schema coverage, the description must clarify parameters. It explicitly clarifies `post_id` by stating it's the real id (from `skool_list_posts`/`skool_get_post`) and not the slug, which is critical for correct invocation. `content` is not described, but it's self-evident from the name and type. The key parameter semantics are addressed well.

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 with a specific verb and resource: 'Add a comment to a post.' It also clarifies the ambiguous `post_id` parameter, distinguishing it from the slug, which prevents misuse. This clearly differentiates it from sibling tools like `skool_create_post` (creating a post) and `skool_send_message` (messaging).

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 some usage context: it's for commenting on posts, and it warns 'Writes publicly — confirm first,' implying user consent is needed. However, it does not explicitly mention when not to use this tool or how it compares to alternatives like sending messages or creating posts. Guidance is implied but not fully spelled out.

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 to rely on, the description fully bears the burden and shines: it explicitly states 'Writes publicly' (a critical side effect), mandates user confirmation, and reveals the return value ('Returns the new post id'). This is exactly the kind of behavioral disclosure needed for a mutation 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?

Three tight, front-loaded sentences. The purpose is stated first, followed by the critical write/confirmation note, then the return. Every sentence adds value; there is zero waste. This is a model of concise, structured description.

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 simple (2 params, no output schema), and the description covers the key operation, public write behavior, and return. It doesn't mention auth requirements or error conditions, but those are typically inferred for such a straightforward create-and-publish tool. Given the lack of annotations, the description is reasonably complete; a 4 is warranted.

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 zero description coverage, and the description doesn't clarify what 'title' and 'content' mean beyond their obvious names. Since the parameters are self-explanatory (a post's title and body), this is acceptable, but the description adds no extra meaning or guidance about constraints or formatting. It's adequate but not more.

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 ('Publish') and resource ('NEW top-level post to your community feed'), clearly distinguishing it from siblings like comment or list operations. The phrase 'top-level' explicitly separates it from comment creation, and the tool's intent 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 good context by specifying it writes publicly and advises confirming wording with the user, which guides when to use it (only after user approval). It doesn't explicitly mention alternatives, but the purpose clarity and sibling names make it obvious when this tool is appropriate. No exclusionary guidance is given, but the behavioral note covers the main usage caveat.

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 is the sole source of behavioral info. It discloses the read-only nature and the return shape (sender, content, timestamp). It does not mention rate limits, ordering, or the effect on read state, but 'read-only' reasonably implies no 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 sentences, front-loaded with purpose and a direct prerequisite. Every sentence adds value, with no wasted words or redundant phrasing.

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 tool, the description covers the key details: how to get the required parameter and what the return contains. Missing are specifics on limit behavior, ordering, and pagination, but these are not critical for a simple read operation 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 description coverage is 0%, so the description must explain parameters. It explains how to obtain channel_id (via list_conversations) but does not describe the limit parameter at all. The meaning of 'limit' must be inferred from context or its default 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 a specific action ('Read the messages') on a specific resource ('one DM conversation'), and explicitly marks it as read-only. It also names the sibling tool to obtain the required channel_id, distinguishing it from list_conversations.

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 a concrete usage step ('Get the channel_id from skool_list_conversations') and implies a context (reading messages, not sending or marking read). It does not explicitly exclude alternatives, but the prerequisite and read-only nature give adequate guidance.

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

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

With no annotations, the description carries the full behavioral burden. It explicitly states the operation is 'read-only', discloses that many lessons are video-only and 'content' may be empty, and indicates what is returned with and without lesson_id. This goes beyond the name and provides essential runtime behavior, though it could mention error handling or response shape in more 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?

Two concise sentences, front-loaded with the core purpose and read-only nature. The alternative behaviors are explained compactly without fluff, and the video-only caveat is included efficiently. Excellent structure and 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 there is no output schema, the description adequately describes the return behavior: modules/lessons list (id+title) without lesson_id, and lesson content/metadata with lesson_id, including a caveat about empty content. It covers the essential information for a read-only tool, though it omits potential error conditions or pagination, but these are not critical for basic usage.

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 explain parameters. It does so effectively: course_id is sourced from skool_list_courses and yields modules/lessons; lesson_id is a child id that triggers content/metadata retrieval. It also warns about empty content. This adds meaning beyond the bare parameter titles, though it doesn't specify formats or constraints.

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

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

The description clearly states the tool's primary action ('Read a classroom course'), the resource (course/lesson), and distinguishes it from sibling tools like skool_get_post and skool_get_conversation by focusing on course/lesson content. It also specifies the scope: without lesson_id it returns modules/lessons, with lesson_id it returns lesson content/metadata, avoiding 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 usage context by directing the agent to obtain course_id from skool_list_courses, and explains the optional lesson_id behavior. It implies a typical workflow (list courses → get lesson) but does not explicitly state when to prefer this tool over alternatives like skool_get_post. Still, the guidance is sufficient for correct invocation.

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 of behavioral disclosure. It discloses the default behavior of including comments ('by default') and clarifies that post_name is a slug, not an id. However, it does not mention authentication requirements, error handling, or side effects (though as a read, side effects are minimal). This is adequate but not exhaustive.

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

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

The description is concise at two sentences, with the action and scope front-loaded. The parameter clarification is seamlessly integrated into the second sentence without redundant phrasing. Every word earns its place, and the structure aids quick comprehension.

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 (2 params, no output schema) and no annotations, the description covers the essential aspects: what it does, the key parameter nuance, and default behavior. It lacks details on error responses or exact return structure, but for a read tool with a clear resource, it is mostly complete. The mention of 'full post' and 'comments' gives a reasonable picture of the return content.

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

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

Schema description coverage is 0%, so the description must compensate. It adds critical meaning to post_name by clarifying it is a slug from skool_list_posts and not an id, which is essential for correct invocation. It also indirectly explains with_comments via the 'by default' phrasing. This adds significant value beyond the bare schema, though not comprehensive for all params.

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 ('Read') and the resource ('one full post' and 'its comments'). It distinguishes from siblings like skool_list_posts (listing) and skool_create_post (creation) by specifying a single post retrieval. The parameter clarification further anchors the 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 indicates when to use this tool by stating it reads one full post, implying it is for single-post retrieval rather than listing. It also references skool_list_posts as the source of post_name, which signals a workflow of listing first then getting details. However, it does not explicitly say when not to use it or name alternatives directly.

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

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

With no annotations provided, the description carries full burden. It explicitly states 'read-only', disclosing that this operation has no side effects. It also lists the output contents (channel_id, unread count, preview), giving the agent a sense of what to expect. It does not mention pagination or rate limits, but for a list operation the key safety trait (read-only) is 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?

Two sentences, no wasted words. The main purpose and scope are front-loaded, and the usage hint about get_conversation is placed after the primary info. Structure is clean 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 simple list tool with one optional parameter and no output schema, the description covers what the tool returns (fields), the scope (DM inbox), safety (read-only), and the natural next step. An agent has enough to invoke it correctly without further ambiguity.

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 only one parameter (limit) with 0% description coverage, and the description does not mention limit at all. While 'limit' is a common parameter, the description fails to explain its effect (e.g., max number of conversations to return, default 30). Since the description is the only place to compensate for the missing schema documentation, this is a notable gap.

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

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

The description clearly states the resource ('DM inbox') and the action (list conversations), and specifies the fields returned (channel_id, unread count, last-message preview). It also distinguishes itself from sibling get_conversation by directing the reader to use it for reading a specific conversation. This is a precise, non-redundant purpose statement.

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

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

The description explicitly tells the agent to use a returned channel_id with skool_get_conversation for follow-up, which implies this tool is for browsing the inbox before drilling into a conversation. It does not explicitly state when not to use it or alternatives, but the pointer to the sibling tool provides clear context. Given the number of siblings and the clear naming, this is adequate.

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

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

With no annotations provided, the description carries the full behavioral burden. It discloses the key trait of being read-only, which implies no side effects or destructive actions. It also indicates what data will be returned. However, it doesn't mention any potential limitations such as pagination, rate limits, or behavior when no courses exist. For a simple list operation, this is adequate but not comprehensive, so a score of 3 is appropriate.

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

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

The description is exactly two concise sentences, with the primary action and scope front-loaded. The first sentence states the purpose and return fields, the second gives a clear pointer to the related lesson tool. There is zero wasted wording, and each word earns its place. This is an ideal structure for clarity and scannability.

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 (no parameters, no output schema), the description provides all necessary information: what the tool does, the scope, the read-only nature, and the exact fields returned. It also suggests how to proceed with a course id. There is no missing information that would prevent an agent from calling the tool correctly. A slightly higher score would require more detail about return edge cases or error handling, but this is not essential for a simple list 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?

The tool has zero parameters, and the schema has 100% coverage (trivially, since there are no properties to document). The description adds no parameter explanations because none are needed. The baseline for zero-parameter tools is 4, and the description doesn't attempt to explain anything beyond the absence of parameters, which is correct. No additional semantic value is required or provided, but the baseline is met.

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 clear verb ('List'), a specific resource ('classroom courses'), and a scope ('in your community'). It also explicitly marks the operation as 'read-only' and lists the returned fields (id, title, description), fully distinguishing it from sibling tools like list_posts or get_lesson. This is a precise, unambiguous statement of 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 tells the agent when to use this tool (to list courses) and directs it to the related tool (skool_get_lesson) for further action, using a course id. While it doesn't explicitly contrast with other listing tools like skool_list_posts, the domain-specific focus and the natural next-step suggestion provide clear practical guidance. It could be more explicit about alternatives, but the intent is clear.

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

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

The description discloses the read-only nature of the operation, which is a key behavioral trait. Beyond that, it does not mention pagination, how the limit parameter affects results, authentication requirements, or potential errors. With no annotations provided, the description carries the full burden but only partially covers the behavioral aspects.

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 primary action and returned fields, followed by a useful cross-reference to skool_start_chat. Every word contributes value, with no redundancy or filler. The structure is clean and immediately scannable.

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 only one parameter and no output schema, the description covers the main purpose, explicitly states the return fields, and offers a practical follow-up action. It is missing an explanation of the limit parameter's behavior and default, but overall it provides enough context for an agent to understand the tool's role and basic use.

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 'limit' is not mentioned in the description at all, and schema description coverage is 0%. The agent receives no guidance on how limit influences the number of members returned or whether there is a default. The description fails to compensate for the lack of schema documentation, leaving the parameter's meaning entirely up to inference from its name and default.

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

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

The description clearly states the action ('List members of your community') and the resource, along with the specific fields returned (id, name, email, short bio). The 'read-only' qualifier distinguishes it from mutation tools, and the resource 'members' differentiates it from sibling list tools like skool_list_posts or skool_list_courses.

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 one concrete usage context: obtaining member ids for use with skool_start_chat to open a DM. However, it does not explicitly compare with alternative list tools or state when not to use this tool. No exclusions or alternative recommendations are given, leaving some ambiguity for an agent deciding between list 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?

No annotations are provided, so the description carries the full burden. It discloses the read-only nature, the returned fields (id, name, title, snippet, counts, author), and the 'recent' scoping. It doesn't mention pagination or ordering details, but for a simple list tool this is adequate.

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

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

Two sentences, no fluff. The core verb and scope are front-loaded, and the return format and cross-tool hint are placed efficiently. Every sentence earns its place.

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

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

For a single-parameter list tool with no output schema, the description provides enough: the purpose, return fields, and a pointer to the next step. The missing explanation of `limit` is the main deficiency, but the overall context is sufficient 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?

Schema description coverage is 0%, and the description does not mention the `limit` parameter at all. While 'limit' is a common concept, the tool fails to explain its effect, bounds, or default behavior beyond the schema's default value. This is a notable gap given the low 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?

States a specific verb ('List'), a resource ('posts in your community feed'), and explicitly notes it is read-only. It also distinguishes itself from skool_get_post by clarifying that this returns a snippet, not full posts. The purpose is unmistakable and differentiates from the main sibling.

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

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

The description explicitly tells the agent to use the returned `name` with skool_get_post for full posts, providing a clear routing condition. It does not address other siblings (e.g., list_members, list_courses), but given the post-specific context, the guidance is sufficient for the common case.

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 for disclosing behavioral traits. It only states the action itself ('Mark as read') without detailing side effects, permissions, reversibility, or any response. For a mutation tool, this is insufficient disclosure, particularly regarding what changes and what the result is.

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. The core action is front-loaded, and the only extra information (the source of the parameter) is presented immediately afterward. 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?

The tool is low complexity (one parameter, no output schema), but the description covers only the action and parameter source. It does not mention the response or any side effects, which might be expected for a mutation tool. Given the minimal annotations and schema richness, the description is adequate for invocation 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 does add value by pointing to the source of the channel_id (skool_list_conversations), which is a helpful hint. However, it does not explain the meaning of 'channel_id' beyond the identifier itself, which is a minor gap for a single 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 action ('Mark a DM conversation as read') with a specific verb and resource. It distinguishes itself from siblings by the action type (e.g., get_conversation, send_message). The phrase 'Get the channel_id from skool_list_conversations' adds context and prevents confusion with other conversation 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 offers clear context by telling the agent how to obtain the required parameter (from skool_list_conversations). It does not explicitly contrast with alternatives, but the purpose is straightforward enough that exclusions are not critical. This meets the 'clear context, no exclusions' bar.

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

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

With no annotations, the description carries the full burden. It states 'Writes', indicating a state-changing operation, and adds a caution to 'confirm wording first', suggesting irreversibility. However, it does not disclose permissions, rate limits, failure modes, or what happens to the conversation. It provides basic but not comprehensive behavioral 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?

Two short sentences, front-loaded with the core action first. The warning follows logically, and the channel_id sourcing is given in a separate sentence. No fluff, 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 2-parameter operation with no output schema, the description covers the essential prerequisite (obtaining channel_id), the write nature, and a caution. It doesn't mention error scenarios or return values, but for this low complexity, it provides enough for an agent to invoke it correctly. Minor gaps are acceptable given the tool's simplicity.

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

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

Schema description coverage is 0%, so the description must explain the parameters. It gives a direct source for channel_id (from list_conversations), and content is implicitly understood as the message text from the verb 'Send'. However, it doesn't specify any constraints, formats, or expectations for content, and doesn't explicitly link content to the parameter. It adds some value but falls short of fully clarifying both 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 action (send a DM), the target (an existing conversation), and the write nature. It distinguishes from starting a new conversation by specifying 'existing', which is a key differentiator from the sibling 'skool_start_chat'.

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 an explicit instruction on how to obtain the channel_id (from skool_list_conversations), which is actionable for the agent. While it doesn't explicitly state when not to use it, the phrase 'existing conversation' implicitly guides away from starting a new chat. This is clear but not fully 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?

With no annotations provided, the description carries the full burden of behavioral disclosure. It covers the core behavior (creates a new DM) and the return value (the conversation), but does not mention side effects, permission requirements, idempotency (whether calling again errors or returns existing), or potential rate limits. It hints at a prerequisite (user_id from skool_list_members) but omits failure scenarios. This is acceptable but not exhaustive.

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

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

The description is a single, tightly worded sentence. It front-loads the primary action and resource, then provides the parameter source, followed by the return value and next step. Every phrase earns its place—no filler, no redundancy. This is an model of concise, structured tool documentation.

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

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

For a tool with only one parameter, no output schema, and no annotations, the description is relatively complete. It states what it does, what it returns, and how to obtain the input. It also indicates the follow-up action (send_message). Missing are potential error scenarios (e.g., invalid user_id, conversation already exists) and any explicit note that authentication is assumed. These are minor gaps given the simplicity.

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

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

Given schema coverage is 0%, the description must add meaning to the single parameter. It does so by specifying the source ('user_id from skool_list_members'), which clarifies that it is the member's identifier from a prior call, not a free-form input. It also implies the parameter is required (which the schema confirms). While it doesn't describe format or validation, the source reference adds significant semantic value beyond the bare 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 explicitly states the tool's action ('Open a new DM') and the resource (a member via user_id). It distinguishes from siblings like skool_send_message (sends to existing conversation) and skool_list_conversations (lists conversations) by specifying it creates a new conversation. The phrase 'so you can then skool_send_message into it' clarifies the intended downstream use.

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 a prerequisite for sending messages to a new member, referencing skool_send_message as the follow-up. It also points to skool_list_members as the source for user_id, giving a clear context. However, it does not explicitly state when NOT to use it (e.g., if a conversation already exists) or contrast with skool_list_conversations as an alternative for existing chats. Thus, it provides clear context but no explicit exclusions.

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

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

With no annotations, the description carries the full burden. It clearly states the two behaviors (cookie check and community listing), implying a read-only operation. It does not mention error handling or response details, but for a whoami-style tool this is largely implied and acceptable.

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

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

Two sentences with no wasted words. The primary purpose is front-loaded, and the critical usage tip follows immediately. Ideal 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?

For a zero-parameter, no-output-schema tool, the description covers the essential purpose and usage context. It could mention expected output format (e.g., list of community names/IDs) or error behavior, but those are minor gaps given the tool's simplicity and the explicit diagnostic hint.

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 the schema is trivially complete. Baseline for 0 params is 4, and the description adds no unnecessary parameter information since none exists. It does not need to compensate.

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 purpose: to confirm cookie validity and list the user's communities. It clearly identifies the tool as an auth check combined with a listing operation, and this distinguishes it from sibling tools like list_posts or list_courses.

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

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

Explicitly tells the agent to call this first if other tools error, framing it as a diagnostic for auth/cookie problems. This provides clear when-to-use guidance and effectively positions it against the other tools.

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