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

Annotations already declare destructiveHint=true, openWorldHint=true, readOnlyHint=false, and idempotentHint=false. The description adds no concrete behavioral context: it does not say which actions mutate or destroy data, what auth is needed, or what limits apply beyond pointing to discord_help. It does not contradict the annotations.

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

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

Two short sentences, with the action list front-loaded and the help pointer kept compact. 'Discord account' slightly restates the tool name, but overall the wording is efficient; under-specification is a completeness issue rather than 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?

For a six-action, potentially destructive account tool with no output schema, the description provides the action enum and an explicit discord_help routing instruction. However, it omits action semantics and destructive specifics, making it minimally usable but not 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 83%, so the schema already documents most parameters. The description does not explain action-specific parameters or IDs; it only defers to discord_help, which is useful routing but not added semantic detail 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?

Names the resource ('Discord account') and enumerates six actions, but does not state what any action does, so edit versus user versus application is left ambiguous. The action list adds scope beyond the name, but an agent still cannot distinguish behavior from siblings without calling discord_help.

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 only guidance is to call discord_help for action-specific details. There is no explicit when-to-use/when-not guidance and no comparison to sibling tools such as discord_guild or discord_members; usage is only implied by the action names.

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

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

Annotations already declare destructiveHint=true, idempotentHint=false and openWorldHint=true, so the safety burden is partly lifted, yet the description adds nothing about what delete removes, whether create/edit are reversible, or what permissions or rate limits apply. It neither contradicts nor enriches the annotation profile beyond pointing at discord_help.

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

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

Three short sentences, front-loaded with the resource and the action list before the escalation pointer. No filler, though the terseness means the escape hatch to discord_help is doing more work than the prose.

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

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

For a six-parameter, five-action destructive tool with nested objects and no output schema, the description supplies no per-action requirements and defers everything to discord_help. The deferral is explicit and actionable, which keeps it viable, but the agent must make an extra call before it can invoke any action correctly.

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

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

Schema description coverage is 83%, so the schema already documents body, files, params, query and reason. The description only tells the agent to fetch per-action required IDs and request fields from discord_help, which is a pointer rather than added semantic meaning. Baseline 3 applies.

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

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

"Discord automod" names the resource and the action enum (list/get/create/edit/delete) implies a CRUD surface for auto-moderation rules, but the description never says what automod actually is or manages. With a sibling named discord_moderation, an agent cannot tell from this text which one covers moderation rules versus automod configuration.

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 only guidance is a documentation-routing instruction ("Call discord_help with group=\"automod\" and action"), which is not a when-to-use rule. There is no statement of when this tool applies versus discord_moderation or any other sibling, and no preconditions such as required permissions.

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

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

Annotations already declare destructiveHint=true, openWorldHint=true, idempotentHint=false, and readOnlyHint=false, so the safety profile is known. The description adds the action inventory (including delete and set_permissions) and points to help for limits, but does not describe side effects, reversibility, auth needs, or rate limits beyond annotations. It does not contradict the annotations.

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

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

Two sentences cover the resource, action list, and routing instruction. It is front-loaded and every element serves selection or parameter discovery, with no fluff.

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

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

For a 10-action multiplexed tool with nested body/query/params and no output schema, the description deliberately offloads action-specific schema and examples to discord_help. That routing is appropriate, but it leaves return behavior and action-level effects unstated, so it is adequate rather than 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 high at 83%, so most parameter documentation is already present in the schema. The description only says to use discord_help for required IDs and request fields; it adds little action-specific parameter semantics beyond that routing. Baseline 3 applies.

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

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

The description names the resource (Discord channels) and enumerates the full action set, so an agent can distinguish it from sibling resource tools like discord_messages or discord_roles. It does not explain what each action does beyond its name, so it is clear but not fully differentiated at the action level.

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 lists the supported actions and instructs the agent to call discord_help with group="channels" and a specific action for IDs, request fields, limits, and examples. That is useful operational routing, but it gives no when-to-use/when-not guidance or explicit comparison to sibling tools such as discord_permissions.

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 flag destructiveHint=true, openWorldHint=true and readOnlyHint=false, so the safety profile is covered. The description adds nothing beyond that: it does not say that guild_delete/global_delete/global_replace_all permanently remove commands, does not mention permission or rate-limit constraints on command registration, and provides no auth context. It defers all behavior to discord_help.

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

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

Two sentences, front-loaded with the action enumeration, with no filler. The action list is long but load-bearing since it is the only statement of scope. The only mild inefficiency is that the enumeration is presented without any grouping or explanation.

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 ten-action, destructive, six-parameter tool with no output schema, the description is essentially a router to discord_help, which is a legitimate design but leaves the agent without any in-definition sense of what each action does or returns. It is complete as a dispatch stub but thin given the tool's complexity and destructive scope.

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

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

Schema description coverage is 83%, so body, files, query, params and reason are already documented in the schema, and the baseline of 3 applies. The description adds only that discord_help supplies the per-action request fields and required IDs, which is a pointer rather than added semantic meaning. It does not explain how params interact with each action.

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 the resource ("Discord commands") and enumerates all ten actions, which tells an agent the tool covers application-command registration at guild and global scope. However, it never says these are application/slash commands, so action names like guild_create and guild_list read ambiguously next to the sibling discord_guild, which plausibly handles servers. The verbs are only in the action names, not explained in prose.

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 routes the agent to discord_help with group="commands" for IDs, fields, limits and examples, which is real delegation guidance. But it gives no when-to-use versus siblings (discord_guild, discord_permissions) and no when-not or prerequisite conditions. Usage is implied by the action list rather than stated.

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 declare destructiveHint=true and openWorldHint=true, yet the description never warns that some listed actions (template_delete, template_sync, template_edit, welcome_edit, onboarding_edit, widget_edit) mutate or destroy server configuration while others (welcome_get, onboarding_get, widget_get, widget_json, templates) are reads. Bundling destructive and read-only actions into one flat list with no risk separation leaves the agent unable to tell which invocations are irreversible.

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: the resource and action set first, then the delegation instruction. The action enumeration is dense but earns its place by exposing the enum values, and there is no filler prose.

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 6-parameter, nested-object, destructive, open-world tool with no output schema, the description supplies almost no behavioral context; it pushes all detail to discord_help. Nothing states what a successful call returns, whether template_sync alters existing guild structure, or what permissions are needed for the edit/delete actions.

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 83% and the schema already explains body, files, query, params, and reason. The description adds only the pointer to discord_help for per-action request fields, which is useful routing but no syntax or constraint detail 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?

It names the resource (Discord community) and enumerates the 12 supported actions, so an agent knows this is a multi-action community-config tool. However, the action names are a bare list with no explanation of what welcome vs onboarding vs widget vs template operations actually do, and nothing distinguishes it from siblings like discord_guild or discord_snapshot beyond the action vocabulary.

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 a concrete routing instruction: call discord_help with group="community" and the action to get required IDs, request fields, limits and examples. That tells the agent how to prepare a call, but it gives no guidance on when to pick this tool over discord_guild, or which action suits which intent, and no exclusions.

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

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

Annotations already declare non-read-only, destructive, open-world, and non-idempotent behavior. The description only repeats the action names and delegates details to discord_help; it adds no specific information about what delete destroys, required permissions, side effects, or rate limits.

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

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

The description is short and front-loaded: resource, action list, then help pointer. The opening 'Discord emojis' fragment is mildly redundant with the tool name but does not materially hurt clarity.

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

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

For a six-parameter, multi-action, destructive tool with nested objects, the description is thin and relies heavily on discord_help for action-specific details. Annotations and schema cover safety and many parameter details, but action-specific behavior and sibling selection guidance remain missing.

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

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

Schema coverage is high at 83%, so the schema already documents body, files, query, params, and reason. The description confirms that action-specific IDs and request fields are obtained via discord_help but does not add parameter format or role semantics 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?

Names the resource ('Discord emojis') and enumerates the five operations (list/get/create/edit/delete), so an agent can identify it as the emoji-management tool. It does not explicitly contrast with sibling resources such as stickers or soundboard, so it stops short of full sibling differentiation.

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 action list implies use for emoji operations and points to discord_help with group="emojis" and action for required IDs, request fields, limits, and examples. However, it gives no explicit when-not guidance or alternative selection criteria against sibling tools, leaving action-specific usage to another tool.

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

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

Annotations already declare destructiveHint=true, openWorldHint=true and non-idempotent, and the description adds essentially nothing beyond that profile — no note on what delete destroys, permission requirements, or rate limits, only a pointer that limits exist in discord_help. The action list (including delete) is consistent with the annotations, so there is no contradiction, but the added behavioral value is minimal.

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

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

Two short sentences, resource and action set front-loaded, with the help pointer second. No filler, though the payoff of the second sentence is purely a redirect.

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 6-parameter, nested, destructive tool with no output schema, the description is a thin wrapper that outsources nearly all detail to discord_help. The explicit handoff makes it usable, but an agent gets no self-contained understanding of return values, limits, or per-action behavior.

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 83%, so the schema already documents body, files, query, params and reason in useful detail. The description only defers to discord_help for 'required IDs, request fields, limits and examples', adding no semantics beyond what the schema provides, making baseline 3 appropriate.

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

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

The description names the resource (Discord events) and enumerates the exact action set (list, get, create, edit, delete, users), which lets an agent distinguish it from siblings such as discord_guild or discord_channels. It stops short of saying what an 'event' is (e.g., scheduled guild events), so the resource is named but not characterized.

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 lists the available actions and directs the agent to discord_help with group="events" for per-action schemas, which is genuine routing guidance. However, it never says when to pick this tool over a sibling or what preconditions apply, leaving selection logic implicit.

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 meaningful behavioral traits beyond the annotations: ephemeral auto-deferral with a 14-minute response window, autocomplete returning no suggestions, and no autonomous AI replies. It does not contradict the annotations and adds useful operational 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 action-oriented, with the main capabilities front-loaded. The additional sentences are short and informative, though the final 'No autonomous AI replies' is slightly abrupt.

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 9-parameter multi-action tool with no output schema and 0% schema description coverage, the description leaves too much unexplained. It covers interaction auto-deferral but omits key information about event reading, connection behavior, status, presence fields, and most parameters.

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

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

Schema description coverage is 0%, but the description only explains the enable_interactions parameter and vaguely references cursor-based bounded reads. Most parameters (after, limit, types, status, activity, activity_type, guild_id) have no semantic explanation in either the schema or the description.

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

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

The description names concrete actions (connect/disconnect the Gateway, read events, set presence) and the resource is clear. It does not mention the 'status' action present in the schema, so it does not fully cover the tool's 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 provides behavioral notes but no explicit guidance on when to use this tool versus siblings such as discord_status or discord_interactions. It also doesn't explain when to choose each action or any prerequisites.

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 destructiveHint=true, openWorldHint=true, idempotentHint=false, and readOnlyHint=false, so the safety profile is known. The description adds the action list (including destructive-sounding delete_integration and leave) and defers limits to discord_help, but it does not explain which actions are destructive, what gets destroyed, permission requirements, or rate-limit behavior. With annotations carrying the core safety disclosure, this is adequate but thin.

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?

It is two sentences with no filler, and the action list is front-loaded. The opening 'Discord guild.' is so terse that it barely functions as a purpose statement, but the description remains efficient and well-structured.

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

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

For a complex, multi-action, destructive-capable guild tool with no output schema, the description delegates almost all operational detail to discord_help. That pointer is important and appropriate, but the description itself does not summarize what each action returns, what resources are affected, or failure modes. Combined with existing annotations and rich schema, it is minimally complete rather than fully 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 83%, so the schema already documents body, files, query, params, and reason well enough. The description adds only the action list and a pointer to discord_help, not meaning beyond the schema for parameters such as guild_id defaults, route IDs, or request fields. Baseline 3 is appropriate.

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

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

The description identifies the resource ('Discord guild') and enumerates the specific actions available (get, preview, edit, audit_log, etc.), so an agent can tell this is the guild-level operations tool rather than a sibling like discord_roles or discord_channels. It is clear but terse, since 'Discord guild' alone does not explain what most actions do.

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 directs the agent to call discord_help with group="guild" and the action for required IDs, request fields, limits, and examples, which is useful procedural guidance. However, it does not say when to use this tool versus sibling tools or when to avoid it, leaving usage context implied by the action list.

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

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

Annotations already declare readOnly, idempotent, non-destructive, and open-world behavior. The description adds useful behavioral detail by specifying that no group yields a catalog summary while group+action yields a detailed schema, though it does not discuss auth or rate limits.

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

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

Two sentences with no wasted words. The core discovery purpose is front-loaded, followed immediately by the conditional return behavior.

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 help/discovery tool with no output schema, the description gives only a high-level distinction between catalog summary and detailed schema. It leaves unresolved what happens with group-only/action-only calls and what the returned schema actually contains.

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 carry parameter meaning. It explains the no-group and group+action cases, but does not clarify group-only behavior, action-only behavior, action format, or how action relates to the group enum.

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 ("Discover") and resource (operations, route IDs, body schema, query fields) and clearly frames this as a catalog/help tool. It does not explicitly contrast itself with the many sibling operation tools, but the name and wording make its meta purpose recognizable.

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

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

It states two calling modes: no group returns the catalog summary, and group+action returns a detailed schema. However, it does not explicitly say when to choose this tool over a sibling tool or that it should be used before invoking a specific operation.

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?

Goes well beyond the annotations (which only declare destructive/openWorld) by disclosing that credentials are internally retained, that initial replies are ephemeral, that tokens expire after 14 minutes, and that modals require a custom immediate handler. These are exactly the operational constraints an agent cannot infer from the schema.

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

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

Six short sentences, each carrying distinct information, with the primary action front-loaded. Slightly list-like and could group the constraints (expiry, modals) more tightly, but there is no filler.

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

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

Covers the hard parts (token handling, expiry, ephemeral replies, body shape) for a destructive, nested-body mutation tool with no output schema. Still leaves gaps on what delete_reply does when invoked and what a deferral/followup flow looks like, which an agent would need before choosing an action.

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

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

Schema description coverage is 0%, so the description must carry the load; it partially does by explaining that `body` follows the Discord.js format and supports content, embeds and components. However, it never explains the `action` enum values (reply vs followup vs delete_reply) or the interaction_id format, leaving the most decision-relevant parameter 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?

States a specific verb and resource: replying to an interaction_ready event from the Gateway, which is clearly distinct from message-sending siblings like discord_messages or discord_commands. It never explicitly names or contrasts those siblings, so differentiation is implicit rather than stated.

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?

Gives a clear triggering condition (an interaction_ready event from the Gateway) and adds a negative constraint (modals are not supported by deferred replies). It stops short of routing the agent to an alternative tool when the interaction is not available or has expired.

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

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

Annotations already declare destructiveHint=true, openWorldHint=true, and idempotentHint=false, so the safety profile is covered. The description adds no behavioral context beyond the action names—no auth requirements, rate limits, or explanation of what delete actually destroys—so it contributes little beyond the structured annotations.

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

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

The description is two short sentences with no wasted words, and the action list is front-loaded. It is appropriately sized, though its extreme brevity means it delegates nearly all useful detail elsewhere.

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

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

This is a destructive, open-world, multi-action tool with nested body/query/params objects and no output schema, yet the description does not explain any action's semantics, required IDs, or effects. It points to discord_help, but that delegation leaves the description itself incomplete for an agent deciding how to invoke it safely.

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 83%, the schema already documents most parameters, so the baseline is 3. The description adds no semantic detail about body, query, params, or reason beyond instructing the agent to consult discord_help, leaving the schema to carry the parameter meaning.

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 identifies the resource ('Discord invites') and enumerates five actions, but it does not use a clear prose verb or explain what each action does. It relies on the action names and a pointer to discord_help, making it minimally viable rather than fully clear.

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 only guidance is to call discord_help with group="invites" and the action for required IDs, fields, limits, and examples. There is no statement of when to use this tool versus sibling tools like discord_guild or discord_channels, nor any when-not guidance.

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

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

Annotations already declare destructiveHint=true, openWorldHint=true, and idempotentHint=false, so the safety profile is covered. The description lists the actions but does not distinguish which are read-only (list/get/search) versus destructive (kick/prune), which would be valuable given this is a mixed tool; it does point to discord_help for limits.

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

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

Two short, front-loaded sentences: resource name, then action enumeration, then the help directive. No wasted text, and the routing cue (discord_help) is clearly placed.

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

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

For a ten-action router tool with nested params and no output schema, delegating detail to discord_help is reasonable, but the description omits behavioral differentiation among actions (read vs destructive) and offers no hint about which actions require the reason or files fields, leaving gaps relative to the tool's complexity.

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

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

Schema description coverage is high (83%), so the schema carries most parameter meaning. The description adds value by directing the agent to discord_help with the specific group and action to learn per-action required IDs, request fields, and limits, which compensates for the enum-driven variability of params across the ten actions.

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 opening 'Discord members' is terse, but the action list (list, get, search, edit, edit_me, add_role, remove_role, kick, prune_count, prune) makes clear this is the member-management tool for Discord. The resource is named and clearly distinguishes it from siblings like discord_roles or discord_channels.

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 how to obtain details by calling discord_help with group='members', which is useful routing guidance. However, it gives no explicit when-to-use versus alternatives (e.g., why members vs roles for role changes) and no exclusions.

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

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

Annotations already declare destructiveHint=true, openWorldHint=true, and idempotentHint=false, so the safety profile is covered. The description does not add meaningful behavioral context beyond pointing to discord_help; it does not state what delete/bulk_delete destroy, permission requirements, or rate-limit behavior.

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

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

The description is short and front-loads the action list, though the opening fragment 'Discord messages.' is redundant with the tool name. The help pointer is useful and nothing is excessively verbose.

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 multi-action, destructive, open-world tool with nested parameters, the description is adequate only because it delegates details to discord_help. It does not fully explain action-specific behavior or sibling differentiation, leaving gaps for an agent that must invoke the correct action safely.

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 high (83%), so the schema already documents most parameter meanings. The description adds only a general pointer that required IDs and request fields vary by action and are documented in discord_help, without explaining specific parameter semantics.

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 identifies the resource (Discord messages) and enumerates the supported actions, making the tool's scope clear enough. It does not explicitly contrast itself with siblings such as discord_channels or discord_reactions, but the action list and resource name provide substantial differentiation.

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 through the action list and the instruction to call discord_help for action-specific IDs, request fields, limits and examples. There is no explicit when-to-use/when-not-to-use guidance or comparison against alternative 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?

Annotations already declare destructiveHint=true, readOnlyHint=false and openWorldHint=true, but the description adds almost nothing on top of them: it doesn't warn that bans are irreversible, what permissions are required, or what rate limits apply. The only behavioral hint is the vague mention of 'limits' in the help pointer.

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 tool's identity and action set before the help pointer. No filler, though the second sentence pushes nearly all substance out of the definition.

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 multi-action tool with a nested body and polymorphic query/params, the description is thin — the semantics of each action live entirely behind discord_help. Given there is no output schema and 83% schema coverage, the explicit pointer to the help tool is the mechanism that makes this definition callable, so it is minimally complete but not self-sufficient.

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

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

Schema description coverage is 83%, so the schema itself carries most parameter meaning and the baseline of 3 applies. The description contributes nothing about individual parameters beyond deferring to discord_help, but that deferral is at least a consistent, discoverable pattern with the sibling discord_help tool.

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 the resource domain (Discord moderation) and enumerates the five actions, so an agent knows the tool's territory. However, it never says what the individual actions do — the distinction between 'bans', 'ban', 'ban_info', and 'bulk_ban' is left entirely to the enum and to discord_help.

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 the action list and by the pointer to discord_help for IDs, request fields, limits and examples. There is no guidance on when to choose this tool over siblings like discord_members or discord_automod, and no exclusions or prerequisites are stated.

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 disclose that the tool is read-only, idempotent, non-destructive, and closed-world. The description adds the useful no-argument listing behavior, but it does not state what happens when both names and bitfield are provided, nor how invalid permission names or malformed bitfields are handled.

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 compact sentences front-load the encode/decode capability and then state the no-argument listing behavior. Every sentence adds useful information without repetition 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 two-parameter codec with rich safety annotations and no output schema, the description covers the main operating modes. However, it leaves an important ambiguity unresolved: both parameters are optional and the description does not specify behavior when both are supplied, nor does it explicitly describe the decoded return shape.

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 carry parameter meaning. It successfully identifies the two conceptual inputs (named permissions and a decimal bitfield) and the no-argument mode, but it does not explain mutual exclusivity, precedence, or the expected format of permission names.

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 dual operation: encode named Discord permissions into a decimal bitfield or decode a bitfield. It also defines the no-argument listing behavior, making the tool's purpose concrete and distinguishable from adjacent Discord resources such as roles and channels.

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

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

It gives clear usage context: "Use for roles and channel overwrites," which tells the agent where permission bitfields are applicable. It does not name an alternative or explicitly exclude scenarios, but no sibling tool appears to duplicate this permission-codec role.

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 flag this as destructive, non-idempotent, and open-world, but the description adds almost no behavioral context beyond repeating the action enum. It does not explain what 'end' does to a poll, whether ending is reversible, what permissions are needed, or what 'voters' returns.

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 and the resource and actions are front-loaded. The first sentence largely restates the tool name, but overall it is efficiently structured.

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

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

For a destructive, open-world tool with six parameters and no output schema, the description provides only a pointer to discord_help and the action names. It leaves out action outcomes, return behavior, permissions, and the practical meaning of ending a poll, so an agent cannot call it safely without consulting another 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 high at 83%, so the schema already carries most parameter meaning. The description adds only a general pointer to discord_help for action-specific required IDs, request fields, limits, and examples, which is useful but does not explain any parameter directly.

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 identifies the resource as Discord polls and lists the two supported actions, voters and end, so an agent can tell this is poll-specific rather than a general message tool. It does not explicitly contrast with any sibling tool, but the domain and action list are clear enough to distinguish it in practice.

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 tells the agent to call discord_help for required IDs and request fields, which is useful prerequisite guidance, but it gives no explicit conditions for when to use this tool versus alternatives. The action names imply usage but do not constitute real when-to-use guidance.

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

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

Annotations already declare destructiveHint=true, readOnlyHint=false, and openWorldHint=true, so the safety profile is partly covered. The description adds no behavioral context beyond delegation: it doesn't say that `clear`/`clear_emoji` remove all reactions, whether permissions like Manage Messages are required, or what limits apply. For a destructive multi-action tool, this is a significant gap.

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 and front-loads the resource and action list. It is efficient, though the second sentence is pure delegation and the action list duplicates the enum.

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

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

With 6 parameters, nested objects, an enum, destructive annotations, and no output schema, the description is thin. The explicit pointer to `discord_help` makes it workable, but the definition is not self-contained and omits behavioral details an agent needs before invoking destructive actions.

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 high (83%), so the schema carries most parameter meaning and baseline 3 is appropriate. The description only adds that `discord_help` should be consulted for required IDs/request fields, which is useful meta-guidance but does not explain any parameter semantics 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 names the resource ('Discord reactions') and lists the action enum values, which makes the tool identifiable. However, it doesn't state what the actions actually do (e.g., 'add a reaction to a message', 'clear all reactions'), so it largely restates the schema enum rather than defining purpose in its own words.

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 explicitly routes the agent to `discord_help` with `group="reactions"` and the action for IDs, fields, limits and examples, which is practical guidance. But it gives no guidance on when to choose one action over another (e.g., remove_own vs remove_user) or any prerequisites/alternatives within the reactions domain.

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

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

Annotations already declare destructiveHint=true, idempotentHint=false and openWorldHint=true, so the description's silence on safety is not fatal, but it adds nothing either: it never says which of the enumerated actions are destructive, whether the bot needs Manage Roles permission, or that the reason field is the audit-log entry. For a tool exposing delete and reorder this is thin, though it does not contradict the annotations.

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

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

Three short sentences, resource first, action list second, escalation path last – nothing redundant. It is terse rather than padded; the brevity is a limitation of substance, not of structure.

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 seven actions, nested body/params/query objects, no output schema, and destructive mutations among the actions, the description should carry more weight. Delegating essentially everything to a separate discord_help call leaves an agent unable to determine required route IDs, permissions, or the effect of delete/reorder without a second round trip.

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 83%, so the schema already explains body, files, query, params and reason. The description adds only a pointer to discord_help for 'required IDs, request fields, limits and examples', which duplicates guidance the schema text already contains; baseline 3 applies.

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

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

Names the resource (Discord roles) and enumerates the seven actions, which is enough to distinguish it from sibling resource groups like discord_members or discord_permissions. However, the action names are simply copied from the schema enum and no action is described in terms of what it actually does (e.g. what member_counts returns, what reorder changes).

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 only guidance is a meta-instruction to call discord_help with group="roles" before acting; there is no explanation of when to choose this tool over a sibling, no prerequisite/scope conditions, and no caution that some actions mutate server state. The agent learns nothing about selection criteria, only where to go for details.

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 readOnly, idempotent, openWorld, and non-destructive, so the safety profile is covered. The description adds a genuinely non-obvious trait: partial failure semantics, where each section reports its own permission error rather than failing the whole call. It stops short of covering response size, pagination, or rate-limit behavior for a multi-section read.

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 tight sentences: the scope and its five sections are front-loaded, and the permission-error caveat follows immediately. No filler or restatement of the tool name.

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

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

With no output schema, the description does partially sketch the return shape by listing sections and noting per-section errors. But for a tool whose only parameter is undocumented and optional-by-schema, it leaves the agent guessing about how to target a guild and whether missing sections mean absent data or denied access.

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

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

The schema has one parameter, guild_id, with zero description coverage, and the description never mentions it or how the target server is selected. The pattern hints at a Discord snowflake, but nothing in the description compensates for the coverage gap or clarifies the unusual non-required status of the sole 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?

States a specific verb ('read') and enumerates exactly which resources are aggregated (settings, roles, channels, emojis, scheduled events), plus the intent behind the aggregation. It doesn't explicitly contrast itself with the single-resource siblings (discord_channels, discord_roles, discord_emojis, discord_events), though the composite framing makes the distinction inferable.

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?

'for planning an appearance/layout change' gives a concrete use case that implies when to reach for this over individual tools. However, there is no explicit when-not guidance or named alternative for single-section reads, so the routing decision is left 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?

Annotations already declare destructiveHint=true, openWorldHint=true and idempotentHint=false, so the safety profile is covered. The description adds nothing about which actions are destructive (delete vs play), required bot permissions, voice-connection prerequisites for play, or rate limits — it defers all of that to discord_help, which softens but does not fill the gap for a destructive multi-action 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 short sentences with the resource stated first and the routing instruction second; nothing is wasted. It is slightly under-informative rather than verbose, but structurally front-loaded and easy to scan.

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 seven-action, destructive, open-world tool with six parameters, nested objects and no output schema, the description is thin and relies entirely on a secondary discord_help call for action semantics. The delegation is a deliberate pattern in this toolset, but an agent cannot invoke create/edit/play correctly without that extra round trip.

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 83%, so the schema already documents body, files, query, params and reason well. The description adds no parameter meaning of its own, only pointing to discord_help for request fields and IDs, which is baseline-appropriate when the schema does the heavy lifting.

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

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

The description names the resource ('Discord soundboard') and enumerates the seven actions, but the action list merely restates the schema enum and never says what each action operates on (create a sound, play a sound in a voice channel). An agent can tell it concerns soundboard management, but the per-action purpose is left implicit.

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

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

It gives a concrete routing instruction: call discord_help with group="soundboard" and the action to obtain required IDs and request fields. That is a useful prerequisite, but there is no guidance on when to choose this tool over siblings like discord_voice or discord_messages, nor any when-not condition.

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

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

Annotations already declare destructiveHint=true, readOnlyHint=false, openWorldHint=true, and idempotentHint=false. The description adds almost nothing beyond that, such as what delete removes, permission requirements, or rate/limit behavior; it merely defers those details to discord_help.

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 definition is compact and front-loads the action list, then gives the discord_help pointer. 'Discord stage.' is vague, but the rest is efficient and free of 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 multi-action, destructive tool with nested objects, the description is thin but routes the agent to discord_help for IDs, request fields, limits, and examples. It is enough to know a helper must be consulted, though not enough for a complete self-contained understanding.

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 high at 83%, so the schema already documents body, files, query, params, and reason. The description only enumerates the action values and points to discord_help, adding no meaningful semantics beyond the structured fields.

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 identifies the resource as 'Discord stage' and enumerates six actions, which gives an agent a rough idea of scope. However, it never defines what a 'stage' is (stage channel/instance) or distinguishes this tool from nearby siblings such as discord_voice, so the purpose remains somewhat vague.

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 lists supported actions but gives no guidance on when to use discord_stage versus discord_voice or other tools. The only direction is to call discord_help for action details, which is a lookup pointer rather than usage guidance.

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

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

Annotations already declare readOnlyHint, idempotentHint, destructiveHint=false, and openWorldHint, so the safety profile is covered. The description adds useful behavioral context by noting it works without a bot token, but it does not describe the return format, output shape, or any rate-limit/auth caveats beyond that single condition.

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

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

Two sentences, front-loaded with the core action and coverage areas. The authentication caveat is placed second, where it is easy to find, and there is no redundant or filler text.

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 diagnostic tool with rich annotations and no output schema, the description covers the purpose and the pre-auth condition reasonably well. However, it leaves the single input parameter completely unexplained, which is a meaningful completeness gap for an agent trying 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?

There is one parameter, check_connection, with 0% schema description coverage and no enum. The description never mentions this parameter, so an agent cannot tell what setting it to true changes versus leaving it at the default false.

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 ('Check') and a concrete set of resources: local setup, optional Discord authentication, default/allowed servers, Gateway, and voice status. This distinguishes it from the resource-specific siblings like discord_gateway and discord_voice, though it does not explicitly state the relationship to those 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 phrase 'Works before a bot token is configured' gives a clear usage context for pre-authentication troubleshooting. However, there is no explicit guidance on when to choose this over discord_gateway, discord_voice, or discord_help, leaving the agent to infer that this is a broad diagnostic check.

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 declare destructiveHint=true, readOnlyHint=false and openWorldHint=true, and the description adds nothing behavioral beyond that — it never says that list/get are safe reads while create/edit/delete mutate or destroy data, nor does it mention permissions, audit logging (despite a reason parameter) or rate limits. For a tool bundling destructive and read-only actions under one coarse annotation set, that gap matters.

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 resource and action list followed by the delegation. No filler, though the entire payload semantics are outsourced rather than summarized.

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

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

With no output schema and a nested body/files/params structure across five actions, the definition relies entirely on the agent calling discord_help for per-action requirements. That is a workable pattern and the pointer is explicit, but the standalone definition leaves an agent without enough to construct an action-specific call.

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

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

Schema coverage is 83%, with the free-form body, query and params objects documented only by pointer to discord_help. The description reinforces that delegation for action-specific IDs and request fields, which is modest added value over the schema but not independent explanation of the 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?

Names the resource (Discord stickers) and enumerates all five supported actions, so the agent knows this is a multiplexed CRUD endpoint for stickers rather than emojis or soundboard. It does not explicitly contrast with the closest siblings, but the resource name does most of the disambiguation.

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 action enum and the pointer to discord_help give an implied workflow for picking an action, but there is no statement of when to prefer this tool over a sibling or what preconditions apply to each action. The delegation to discord_help is useful routing, not usage guidance.

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

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

Annotations already declare destructiveHint=true and openWorldHint=true, but the description does nothing to localize that risk to specific actions such as leave, remove_member, or archive-related mutations, nor does it flag that read-style actions (active, archived_public) are non-destructive. It also omits permission/audit expectations despite exposing a `reason` parameter, leaving the behavioral picture thin beyond the generic 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 short sentences, front-loaded with the resource and the full action enumeration, then the delegation pointer. The long action list earns its place as the primary dispatch surface, though the bare enumeration lacks grouping by read vs. write.

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

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

This is a high-complexity multiplexed tool: 11 actions, nested objects (files, params, query), destructive behavior, and no output schema. Offloading all detail to discord_help leaves the agent unable to distinguish similar actions (active vs archived_public vs archived_joined) or know what each returns, which is a substantial gap for a tool of this breadth.

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 83%, so the schema already documents body, files, query, params, and reason; the description adds no parameter meaning it does not already contain, only a pointer to discord_help. Baseline 3 is appropriate when the schema carries the semantic load.

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 the resource (Discord threads) and enumerates the concrete operations (create, from_message, active, archived_*, join/leave, member management), so an agent can see the tool's scope at a glance. It does not explicitly contrast itself with siblings such as discord_channels or discord_messages, but the resource name plus action list 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?

Usage is only implied through the action names; the sole explicit instruction is to call discord_help with group="threads" for IDs and request fields. There is no guidance on when to pick this tool over discord_channels (e.g., public vs private archive listing, or creating a thread from a message vs standalone), so selection still requires 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?

Annotations only declare it is not read-only and is open-world; the description adds real behavioral context: the FFmpeg/Opus/DAVE encryption stack, the existence of a 'dependencies' action to verify prerequisites, and a scope boundary (no recording/transcription). It omits permission requirements (Connect/Speak) and what happens to queued audio on leave or stop, so it's strong but not complete.

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

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

Four tight sentences: capability first, action list second, sibling routing third, scope boundary last. Nothing is redundant, though the FFmpeg/Opus/DAVE stack name-drop is borderline detail that could be shortened.

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 7-parameter, no-output-schema, multi-action tool, the description covers purpose and alternatives well but leaves the parameter-to-action mapping (which params matter for which action) and the shape of 'status'/'dependencies' results unspecified. Adequate to start, but gaps force schema inspection or trial and error.

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% across 7 parameters, so the description carries the full burden. It only gestures at semantics: the action list is inferable, enqueue is implied by 'play/queue', and self_deaf gets one hint for the soundboard path. file, volume, guild_id and channel_id receive no explanation at all, and the enum values are never mapped to required 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?

States specific verbs and resources: join/leave a voice or stage channel, plus play/queue local audio, with the action list spelled out. It also names the sibling it does not replace (discord_soundboard.play) and disclaims recording/transcription, so an agent can distinguish it from discord_stage, discord_soundboard and the rest without opening the schema.

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?

Gives a concrete routing rule for the soundboard case (join with self_deaf=false, then call discord_soundboard.play) and an explicit when-not (does not record or transcribe). It stops short of saying when to prefer join+play over a separate stage flow, or when the 'dependencies' action should be checked first.

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

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

Annotations already declare destructiveHint=true, openWorldHint=true, readOnlyHint=false and idempotentHint=false, so the safety bar is lower. The description adds a pointer to where limits and required IDs live, but it does not distinguish the read-only actions from the irreversible deletes bundled under one destructive annotation, nor mention permissions or rate limits beyond the word 'limits'.

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

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

Two sentences, front-loaded with the resource and the action enum, then the help pointer. The action list is long but carries real information and there is no filler.

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

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

For a ten-action multiplexed tool with nested body/query/params objects and no output schema, deferring per-action semantics to discord_help is a defensible pattern and the agent has a clear path to the missing detail. Still, the description itself leaves a caller unable to choose between, say, create and execute, or to know which actions return data.

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 83%, so body, files, query and params are already documented structurally, including the $file asset convention. The description adds only a generic redirect to discord_help for request fields, which does not extend meaning beyond the schema; baseline 3 applies.

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

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

The description names the resource (Discord webhooks) and enumerates the ten actions the dispatcher supports, which is enough for an agent to know this is the webhook management surface. It does not explain what any individual action does, and the mix of read actions (guild_list, channel_list, get) and write actions (create, edit, delete, execute) makes the single-sentence scope statement thin.

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 a clear next step — call discord_help with group="webhooks" and the action name for IDs, fields, limits and examples — which is useful routing guidance. It offers no when-to-use-this-vs-alternatives guidance against siblings such as discord_channels or discord_messages, and no prerequisites or exclusions.

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