mcp-discord

Server Quality Checklist

Profile completionA complete profile improves this server's visibility in search results.

Latest release: v0.1.0
Disambiguation4/5
Most tools have distinct purposes targeting specific Discord resources and actions, such as send_message vs. edit_message or kick_user vs. timeout_user. However, some overlap exists: add_reaction and remove_reaction are clear, but get_reactions could be confused with list_messages for reading message content, and list_active_threads vs. create_thread might cause minor ambiguity in thread management scenarios.
Naming Consistency5/5
All tools follow a consistent snake_case naming pattern with a clear verb_noun structure, such as discord_send_message, discord_get_channel, and discord_list_members. The naming is predictable and uniform across all 26 tools, making it easy for agents to understand and select the appropriate tool.
Tool Count3/5
With 26 tools, the count is on the higher side for a Discord bot server, which may feel heavy and potentially overwhelming for agents. While Discord's API is feature-rich, this many tools could lead to decision paralysis or misselection, though it does cover a broad range of functionalities from messaging to moderation.
Completeness4/5
The tool set provides comprehensive coverage for core Discord bot operations, including CRUD for messages, roles, and members, as well as moderation actions like kick and timeout. Minor gaps exist, such as no tools for editing roles or managing invites, but agents can still handle most common workflows effectively without significant dead ends.
Average 3.8/5 across 26 of 26 tools scored. Lowest: 2.7/5.
See the Tool Scores section below for per-tool breakdowns.
- No community issues in the last 6 months
- 0 commits in the last 12 weeks
- No stable releases found
- No critical vulnerability alerts
- No high-severity vulnerability alerts
- No code scanning findings
- CI status not available
This repository is licensed under MIT License.
This repository includes a README.md file.
No tool usage detected in the last 30 days. Usage tracking helps demonstrate server value.
Tip: use the "Try in Browser" feature on the server page to seed initial usage.
Add a glama.json file to provide metadata about your server.
If you are the author, simply .
If the server belongs to an organization, first add glama.json to the root of your repository:
```
{
  "$schema": "https://glama.ai/mcp/schemas/server.json",
  "maintainers": [
    "your-github-username"
  ]
}
```
Then . Browse examples.
Add related servers to improve discoverability.

How to sync the server with GitHub?

Servers are automatically synced at least once per day, but you can also sync manually at any time to instantly update the server profile.

To manually sync the server, click the "Sync Server" button in the MCP server admin interface.

How is the quality score calculated?

The overall quality score combines two components: Tool Definition Quality (70%) and Server Coherence (30%).

Tool Definition Quality measures how well each tool describes itself to AI agents. Every tool is scored 1–5 across six dimensions: Purpose Clarity (25%), Usage Guidelines (20%), Behavioral Transparency (20%), Parameter Semantics (15%), Conciseness & Structure (10%), and Contextual Completeness (10%). The server-level definition quality score is calculated as 60% mean TDQS + 40% minimum TDQS, so a single poorly described tool pulls the score down.

Server Coherence evaluates how well the tools work together as a set, scoring four dimensions equally: Disambiguation (can agents tell tools apart?), Naming Consistency, Tool Count Appropriateness, and Completeness (are there gaps in the tool surface?).

Tiers are derived from the overall score: A (≥3.5), B (≥3.0), C (≥2.0), D (≥1.0), F (<1.0). B and above is considered passing.

Tool Scores

Behavior2/5
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
No annotations are provided, so the description carries full burden. It mentions what data is fetched but lacks behavioral details: no information on permissions required, rate limits, error handling (e.g., if member not found), or response format. For a read operation with zero annotation coverage, this is a significant gap in transparency.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Conciseness4/5
Is the description appropriately sized, front-loaded, and free of redundancy?
The description is front-loaded with the core purpose and efficiently lists key data fields. It uses a single sentence with no wasted words, making it easy to scan. However, the lack of additional context slightly reduces effectiveness, but it remains appropriately sized.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Completeness2/5
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
Given no annotations, no output schema, and 0% schema coverage, the description is incomplete. It covers what data is fetched but misses critical context: parameter details, behavioral traits, error cases, and output structure. For a tool with two required parameters and no structured support, this leaves too many gaps for reliable agent use.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Parameters2/5
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 doesn't explain the parameters guild_id and user_id at all—no details on format (e.g., numeric IDs), sourcing, or constraints. The description adds no meaning beyond the bare schema, failing to address the coverage gap.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Purpose4/5
Does the description clearly state what the tool does and how it differs from similar tools?
The description clearly states the verb 'Fetch' and resource 'guild member', specifying what data is retrieved (nickname, joined_at, roles, timeout). It distinguishes from siblings like discord_list_members (which lists multiple members) by focusing on a single member lookup. However, it doesn't explicitly contrast with discord_get_guild or discord_get_message, which slightly limits differentiation.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Usage Guidelines2/5
Does the description explain when to use this tool, when not to, or what alternatives exist?
No explicit guidance on when to use this tool versus alternatives. It doesn't mention prerequisites (e.g., needing guild_id and user_id), when not to use it (e.g., for bulk operations), or direct comparisons to siblings like discord_list_members. Usage is implied by the action 'Fetch', but no contextual rules are provided.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Behavior2/5
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
No annotations are provided, so the description carries the full burden of behavioral disclosure. It states the action ('Remove') but doesn't describe what happens after removal (e.g., if it's permanent, requires specific permissions, affects user access, or has rate limits). For a mutation tool with zero annotation coverage, this is a significant gap in transparency.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Conciseness5/5
Is the description appropriately sized, front-loaded, and free of redundancy?
The description is a single, clear sentence that efficiently conveys the core action without unnecessary words. It's front-loaded with the main purpose, making it easy to parse. Every word earns its place, and there's no redundancy or fluff.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Completeness2/5
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
Given the complexity (a mutation tool with 4 parameters), lack of annotations, and no output schema, the description is incomplete. It doesn't explain the outcome, error conditions, or behavioral details needed for safe and effective use. The minimal description leaves too many gaps for a tool that modifies user roles in a Discord guild.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Parameters2/5
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
Schema description coverage is 0%, meaning none of the 4 parameters are documented in the schema. The description doesn't add any meaning beyond the parameter names (e.g., what 'guild_id', 'user_id', 'role_id', or 'reason' represent, their formats, or constraints). It fails to compensate for the low schema coverage, leaving parameters largely unexplained.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Purpose4/5
Does the description clearly state what the tool does and how it differs from similar tools?
The description clearly states the action ('Remove') and target ('a role from a guild member'), making the purpose immediately understandable. It doesn't explicitly distinguish from sibling tools like 'discord_add_role' or 'discord_kick_user', but the verb 'Remove' implies a specific operation. It's not tautological with the name 'discord_remove_role' as it elaborates on the action.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Usage Guidelines2/5
Does the description explain when to use this tool, when not to, or what alternatives exist?
The description provides no guidance on when to use this tool versus alternatives. It doesn't mention prerequisites (e.g., permissions needed), when not to use it (e.g., for temporary roles vs. permanent removal), or compare it to siblings like 'discord_add_role' or 'discord_kick_user'. Usage is implied by the action but lacks explicit context.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Behavior2/5
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
No annotations are provided, so the description carries the full burden of behavioral disclosure. It states the action ('Unpin') but doesn't describe permissions required (e.g., manage messages), side effects (e.g., message remains in channel), error conditions, or response format. For a mutation tool with zero annotation coverage, this leaves significant gaps in understanding how it behaves.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Conciseness5/5
Is the description appropriately sized, front-loaded, and free of redundancy?
The description is a single, efficient sentence that gets straight to the point with zero wasted words. It's front-loaded with the core action and resource, making it easy to parse quickly. Every word earns its place by conveying essential information without redundancy.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Completeness2/5
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
Given the tool's mutation nature, lack of annotations, no output schema, and 0% schema description coverage for 3 parameters, the description is incomplete. It states what the tool does at a high level but omits critical details about inputs, permissions, behavior, and results, leaving the agent with insufficient context to use it effectively.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Parameters2/5
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 by explaining parameters, but it adds no information beyond the action. It doesn't mention 'channel_id', 'message_id', or 'reason', leaving all three parameters undocumented. The description fails to provide any semantic context for what these inputs mean or how they should be used.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Purpose4/5
Does the description clearly state what the tool does and how it differs from similar tools?
The description clearly states the action ('Unpin') and the resource ('a previously pinned message'), making the purpose immediately understandable. It doesn't explicitly differentiate from sibling tools like 'discord_pin_message' or 'discord_delete_message', but the verb 'Unpin' is specific enough to imply its unique function within the Discord API context.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Usage Guidelines2/5
Does the description explain when to use this tool, when not to, or what alternatives exist?
The description provides no guidance on when to use this tool versus alternatives. It doesn't mention prerequisites (e.g., needing a pinned message first), compare it to 'discord_pin_message' for pinning operations, or clarify when unpinning is appropriate versus deleting a message. The agent must infer usage from the tool name alone.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Behavior2/5
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 states 'Fetch details' which implies a read-only operation, but doesn't cover critical aspects like authentication requirements, rate limits, error handling, or response format. This is a significant gap for a tool with potential API constraints.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Conciseness5/5
Is the description appropriately sized, front-loaded, and free of redundancy?
The description is a single, efficient sentence that front-loads the core purpose ('Fetch details for a single guild') followed by illustrative examples. Every word earns its place with zero redundancy or unnecessary elaboration.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Completeness2/5
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
For a tool with 2 parameters, 50% schema coverage, no annotations, and no output schema, the description is incomplete. It doesn't address behavioral aspects like authentication, rate limits, or error cases, nor does it explain the return format. This leaves significant gaps for an AI agent to use the tool effectively.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Parameters3/5
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
Schema description coverage is 50% (only 'with_counts' has a description). The description adds no parameter-specific information beyond what's implied by 'guild' context. It doesn't explain the 'guild_id' parameter or provide examples, leaving half the parameters undocumented. Baseline 3 is appropriate as the schema covers some ground but description adds minimal value.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Purpose4/5
Does the description clearly state what the tool does and how it differs from similar tools?
The description clearly states the verb 'Fetch' and resource 'details for a single guild', with examples like name, icon, owner, etc. It distinguishes from siblings like discord_list_guilds (which lists multiple guilds) by specifying 'a single guild', but doesn't explicitly contrast with other fetch tools like discord_get_channel or discord_get_member.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Usage Guidelines2/5
Does the description explain when to use this tool, when not to, or what alternatives exist?
No explicit guidance on when to use this tool versus alternatives is provided. It doesn't mention when to choose this over discord_list_guilds for bulk operations or discord_get_member for user-specific data. The description implies usage for retrieving guild details but lacks context about prerequisites or exclusions.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Behavior2/5
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
No annotations are provided, so the description carries full burden. It indicates a read operation ('Fetch') and hints at use for context reading, but fails to disclose critical behavioral traits such as permissions needed, rate limits, error handling, or what data is returned. This leaves significant gaps for a tool with no annotation coverage.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Conciseness5/5
Is the description appropriately sized, front-loaded, and free of redundancy?
The description is front-loaded with the core purpose in the first sentence and adds a brief usage hint in the second. Both sentences earn their place by providing essential information without redundancy, making it efficiently structured.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Completeness2/5
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
Given the tool's complexity (2 parameters, no annotations, no output schema), the description is incomplete. It doesn't cover parameter meanings, return values, error conditions, or behavioral constraints, leaving the agent with insufficient information to use the tool effectively beyond basic intent.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Parameters2/5
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 for the two undocumented parameters. It mentions 'by ID' which relates to 'message_id,' but doesn't explain 'channel_id' or provide any details on parameter formats, constraints, or relationships. This adds minimal value beyond the bare schema.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Purpose4/5
Does the description clearly state what the tool does and how it differs from similar tools?
The description clearly states the action ('Fetch') and resource ('a single message by ID'), making the purpose understandable. However, it doesn't explicitly differentiate from sibling tools like 'discord_get_channel' or 'discord_list_messages', which would require more specific scope clarification.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Usage Guidelines3/5
Does the description explain when to use this tool, when not to, or what alternatives exist?
The description provides implied usage context with 'Useful for reading context before acting,' suggesting it's for preparatory reads. However, it lacks explicit guidance on when to use this versus alternatives like 'discord_list_messages' or 'discord_get_channel,' and doesn't mention prerequisites or exclusions.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Behavior2/5
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
No annotations are provided, so the description carries the full burden of behavioral disclosure. It mentions 'fetch details' but does not specify whether this is a read-only operation, requires permissions, has rate limits, or returns error types. The mention of 'rate limit' in the examples is ambiguous—it could refer to channel settings or API constraints. This leaves critical behavioral traits unclear for a tool that likely interacts with an external API.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Conciseness5/5
Is the description appropriately sized, front-loaded, and free of redundancy?
The description is a single, efficient sentence that front-loads the core purpose ('Fetch details about a single channel') and follows with specific examples. There is no redundant or verbose language, making it easy to parse and understand quickly.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Completeness3/5
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
Given the tool's moderate complexity (fetching channel details from an external service), no annotations, no output schema, and low schema description coverage, the description is minimally adequate. It covers the purpose and hints at return data but lacks behavioral details, error handling, and explicit parameter guidance. This leaves gaps that could hinder effective tool use in varied contexts.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Parameters4/5
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
The input schema has 1 parameter with 0% description coverage, so the description must compensate. It does not explicitly mention the channel_id parameter, but implies it by referring to 'a single channel'. However, it adds semantic context by listing the types of details fetched (e.g., name, type, permission overwrites), which helps the agent understand what information will be returned, partially offsetting the lack of schema descriptions.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Purpose4/5
Does the description clearly state what the tool does and how it differs from similar tools?
The description clearly states the verb 'fetch' and the resource 'details about a single channel', with examples of specific attributes like name, type, and permission overwrites. It distinguishes from sibling tools like discord_list_channels (which lists multiple channels) by specifying 'single channel', but does not explicitly contrast with other read tools like discord_get_message or discord_get_member.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Usage Guidelines2/5
Does the description explain when to use this tool, when not to, or what alternatives exist?
The description provides no guidance on when to use this tool versus alternatives. It does not mention prerequisites (e.g., needing channel access), compare to discord_list_channels for bulk retrieval, or specify use cases like checking channel settings before modifications. Without such context, the agent must infer usage from the tool name alone.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Behavior2/5
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 states the tool lists channels, implying a read-only operation, but doesn't mention permissions required, rate limits, pagination, or the format of returned data. This leaves significant gaps for a tool that likely interacts with an external API.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Conciseness5/5
Is the description appropriately sized, front-loaded, and free of redundancy?
The description is a single, efficient sentence that front-loads the core purpose ('List all channels in a guild') and adds clarifying detail ('Includes text, voice, category, thread channels'). Every word earns its place with no redundancy or fluff.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Completeness3/5
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
Given 1 parameter with no schema descriptions and no output schema, the description is minimally adequate but incomplete. It covers the resource scope but lacks details on permissions, data format, or error handling. For a simple list tool, this might suffice, but the absence of annotations and output schema means more context would be helpful.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Parameters4/5
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
The input schema has 1 parameter (guild_id) with 0% description coverage, so the description must compensate. It adds meaning by clarifying that guild_id refers to a 'guild (server)', which helps interpret the parameter. However, it doesn't specify the format (e.g., numeric ID) or where to find it, leaving some ambiguity.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Purpose4/5
Does the description clearly state what the tool does and how it differs from similar tools?
The description clearly states the verb ('List') and resource ('channels in a guild'), specifying it includes text, voice, category, and thread channels. It distinguishes from siblings like discord_get_channel (singular) and discord_list_active_threads (only threads), but doesn't explicitly contrast with discord_list_guilds or discord_list_members, which operate on different resources.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Usage Guidelines2/5
Does the description explain when to use this tool, when not to, or what alternatives exist?
No explicit guidance on when to use this tool versus alternatives is provided. While the description implies it's for listing all channel types in a guild, it doesn't mention when to choose this over discord_get_channel (for a single channel) or discord_list_active_threads (for threads only), nor does it address prerequisites like needing guild access.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Behavior3/5
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 effectively describes key behavioral traits: pagination mechanism (using cursors), default limit (50), and maximum limit (100). However, it doesn't cover other important aspects like rate limits, authentication requirements, error conditions, or what the return format looks like (e.g., message objects with content, timestamps, authors). The description adds value but leaves significant gaps for a tool with no annotation support.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Conciseness5/5
Is the description appropriately sized, front-loaded, and free of redundancy?
The description is perfectly concise and front-loaded: the first sentence states the core purpose, followed by essential behavioral details in subsequent clauses. Every sentence earns its place by providing critical information about pagination and limits without any redundant or vague language. The structure efficiently communicates what's needed in minimal space.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Completeness3/5
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
Given the complexity (5 parameters, no annotations, no output schema), the description is moderately complete. It covers the basic operation, pagination mechanism, and limits adequately. However, for a tool with no output schema, it should ideally describe what the return values look like (e.g., array of message objects with fields). The absence of annotations means the description should also address safety/authentication concerns, which it doesn't. It's sufficient for basic use but incomplete for full agent understanding.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Parameters3/5
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
Schema description coverage is 80% (4 out of 5 parameters have descriptions), so the baseline is 3. The description adds some context by mentioning that before/after/around are 'cursors' for pagination and specifying the default/max for limit, which complements the schema's numeric range description. However, it doesn't provide additional meaning for channel_id or clarify the mutual exclusivity/relationships between the pagination parameters beyond what the schema already indicates.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Purpose4/5
Does the description clearly state what the tool does and how it differs from similar tools?
The description clearly states the action ('Fetch recent messages') and resource ('from a channel'), making the purpose immediately understandable. It distinguishes itself from siblings like discord_get_message (singular) and discord_send_message, though it doesn't explicitly contrast with discord_bulk_delete_messages which also operates on multiple messages. The description is specific but could be slightly more differentiated from similar list operations.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Usage Guidelines3/5
Does the description explain when to use this tool, when not to, or what alternatives exist?
The description implies usage through mention of pagination parameters (before/after/around) and default/max limits, suggesting when to use this for retrieving message batches. However, it doesn't explicitly state when to choose this over alternatives like discord_get_message for single messages or discord_list_active_threads for thread content. No clear exclusions or prerequisites are provided.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Behavior3/5
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 mentions the permission requirement ('Requires View Audit Log permission'), which is a key behavioral trait for access control. However, it lacks details on rate limits, pagination behavior (beyond the 'before' parameter in schema), error handling, or what the response looks like (since no output schema exists). This leaves gaps in transparency for a read operation.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Conciseness5/5
Is the description appropriately sized, front-loaded, and free of redundancy?
The description is front-loaded with the core purpose ('Fetch recent audit log entries'), followed by filtering details and permission requirement in just two sentences. Every sentence earns its place by providing essential information without redundancy, making it appropriately sized and efficient.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Completeness3/5
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
Given the tool's complexity (5 parameters, no annotations, no output schema), the description is somewhat complete but has gaps. It covers the purpose, filtering, and permission needs, but lacks details on return values, error cases, or behavioral constraints like rate limits. For a tool with moderate complexity and no structured output, more context would improve completeness.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Parameters4/5
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
The description adds meaningful context beyond the input schema by explaining that filtering can be done by 'action_type (Discord AuditLogEvent enum integer) and/or user_id,' which clarifies the purpose of those parameters. With schema description coverage at 80%, the schema already documents most parameters well, but the description enhances understanding of filtering semantics, compensating slightly for the coverage gap.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Purpose4/5
Does the description clearly state what the tool does and how it differs from similar tools?
The description clearly states the tool's purpose with a specific verb ('Fetch') and resource ('recent audit log entries'), and mentions filtering capabilities. However, it doesn't explicitly differentiate from sibling tools like 'discord_get_guild' or 'discord_get_member' which might also retrieve guild-related information, though audit logs are distinct.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Usage Guidelines3/5
Does the description explain when to use this tool, when not to, or what alternatives exist?
The description provides some context by stating 'Requires View Audit Log permission,' which implies when to use it (when that permission is available). However, it doesn't offer explicit guidance on when to choose this tool over alternatives like 'discord_get_guild' for general guild info or other audit-related tools (none exist in siblings), leaving usage somewhat implied rather than clearly defined.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Behavior2/5
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 mentions the tool lists threads but does not disclose behavioral traits such as permissions required, rate limits, pagination, or response format. This is a significant gap for a tool with no annotation coverage.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Conciseness5/5
Is the description appropriately sized, front-loaded, and free of redundancy?
The description is a single, efficient sentence that front-loads the core purpose without unnecessary words. Every part of the sentence earns its place by specifying the action, resource, and scope.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Completeness2/5
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
Given the complexity (listing threads in a guild), lack of annotations, and no output schema, the description is incomplete. It does not cover behavioral aspects like permissions, rate limits, or return values, which are crucial for effective tool use.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Parameters4/5
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
The description adds meaning by specifying that the guild_id parameter is used to list threads in a guild. With 0% schema description coverage and only one parameter, this compensates adequately, though it could provide more context (e.g., format of guild_id).
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Purpose5/5
Does the description clearly state what the tool does and how it differs from similar tools?
The description clearly states the specific action ('List') and resource ('all active (non-archived) threads in a guild'), distinguishing it from siblings like discord_list_channels or discord_list_messages. It precisely defines the scope as 'active (non-archived)' threads, avoiding ambiguity.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Usage Guidelines3/5
Does the description explain when to use this tool, when not to, or what alternatives exist?
The description implies usage when needing to list active threads in a guild, but does not explicitly state when to use this tool versus alternatives (e.g., discord_list_channels for channels, discord_list_messages for messages). No exclusions or prerequisites are mentioned, leaving some context gaps.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Behavior2/5
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 mentions the tool lists guilds but lacks behavioral details such as pagination, rate limits, authentication requirements, or error handling. For a read operation with no annotation coverage, this is a significant gap in transparency.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Conciseness5/5
Is the description appropriately sized, front-loaded, and free of redundancy?
The description is two concise sentences with zero waste. The first sentence states the purpose, and the second adds contextual value ('Useful for multi-server setups'), making it front-loaded and efficiently structured.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Completeness3/5
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
Given the tool's low complexity (one optional parameter, no output schema, no annotations), the description is minimally adequate. It covers the basic purpose and usage context but lacks details on behavior (e.g., response format, limitations), leaving gaps for an AI agent to operate effectively.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Parameters3/5
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
The input schema has 100% description coverage, with the 'limit' parameter fully documented. The description does not add any parameter-specific information beyond what the schema provides, so it meets the baseline score of 3 for high schema coverage without extra value.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Purpose5/5
Does the description clearly state what the tool does and how it differs from similar tools?
The description clearly states the verb ('List') and resource ('all guilds (servers) the bot is a member of'), making the purpose specific and unambiguous. It distinguishes from siblings like 'discord_get_guild' (which retrieves a single guild) by emphasizing 'all guilds' for enumeration.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Usage Guidelines4/5
Does the description explain when to use this tool, when not to, or what alternatives exist?
The description provides clear context ('Useful for multi-server setups'), indicating when this tool is appropriate. However, it does not explicitly state when not to use it or name alternatives (e.g., 'discord_get_guild' for single guild details), which prevents a perfect score.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Behavior3/5
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 states the action ('Send a new message') and return value ('Returns the created message object including its ID'), which implies a write operation with output. However, it lacks details on permissions required, rate limits, error conditions, or side effects (e.g., message visibility, notifications), leaving gaps in behavioral context 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.
Conciseness5/5
Is the description appropriately sized, front-loaded, and free of redundancy?
The description is front-loaded with the core purpose in the first sentence, followed by key features and return value in a second sentence. Every sentence earns its place by adding value (e.g., listing capabilities, specifying output), with zero waste or redundancy, making it efficiently structured and appropriately sized.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Completeness3/5
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
Given the tool's complexity (6 parameters, mutation operation) and lack of annotations and output schema, the description is partially complete. It covers the basic action, features, and return value, but for a mutation tool, it should ideally include more behavioral context (e.g., permissions, errors) or output details. The schema compensates for parameter documentation, but overall completeness is adequate with clear gaps.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Parameters3/5
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
Schema description coverage is 100%, so the schema already documents all 6 parameters thoroughly (e.g., channel_id as 'Snowflake ID of the target channel', content with char limits). The description adds minimal value beyond the schema by mentioning 'plain text, embeds, replies, and allowed_mentions control', which loosely maps to parameters but doesn't provide additional syntax or format details. Baseline 3 is appropriate as the schema does the heavy lifting.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Purpose5/5
Does the description clearly state what the tool does and how it differs from similar tools?
The description clearly states the action ('Send a new message') and resource ('to a Discord channel'), distinguishing it from siblings like discord_edit_message (edits existing messages) or discord_send_typing (shows typing indicator). It specifies the tool's capabilities (plain text, embeds, replies, allowed_mentions control) and return value, making the purpose highly specific and differentiated.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Usage Guidelines4/5
Does the description explain when to use this tool, when not to, or what alternatives exist?
The description implies usage context by listing supported features (e.g., embeds, replies), which helps an agent decide when to use this tool versus alternatives like discord_edit_message for updates or discord_send_typing for non-message actions. However, it lacks explicit when-not-to-use guidance or direct sibling comparisons, such as clarifying that discord_bulk_delete_messages is for removal, not sending.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Behavior3/5
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
With no annotations provided, the description carries the full burden. It discloses the return format ('role objects') and sorting behavior ('sorted by position, highest first'), which is valuable context. However, it lacks details on permissions, rate limits, or pagination, leaving gaps for a read operation.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Conciseness5/5
Is the description appropriately sized, front-loaded, and free of redundancy?
The description is front-loaded with the core purpose in the first sentence and adds behavioral detail in the second. Both sentences earn their place with zero waste, making it highly efficient and well-structured.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Completeness4/5
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
Given the tool's low complexity (one parameter, no output schema, no annotations), the description is mostly complete. It covers purpose, behavior, and parameter context, but could improve by addressing permissions or error handling, though not strictly required for this simple tool.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Parameters4/5
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
The schema has 0% description coverage, but the description adds meaning by clarifying that the single parameter 'guild_id' is used to specify the guild for listing roles. Since there is only one parameter, the baseline is 4, and the description provides adequate context without redundancy.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Purpose5/5
Does the description clearly state what the tool does and how it differs from similar tools?
The description clearly states the specific action ('List all roles') and resource ('in a guild'), distinguishing it from siblings like discord_list_channels or discord_list_members. It provides precise scope and verb usage.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Usage Guidelines3/5
Does the description explain when to use this tool, when not to, or what alternatives exist?
The description implies usage for retrieving roles in a guild, but does not explicitly state when to use this tool versus alternatives (e.g., discord_get_guild for guild info or discord_get_member for member roles). No exclusions or prerequisites are mentioned.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Behavior3/5
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
With no annotations provided, the description carries the full burden. It discloses key behavioral traits: the conditional creation modes and auto_archive_duration options. However, it lacks details on permissions required, error conditions, rate limits, or what happens on success (e.g., thread ID returned). For a mutation tool with zero annotation coverage, this leaves gaps in safety and 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.
Conciseness5/5
Is the description appropriately sized, front-loaded, and free of redundancy?
The description is front-loaded with the core purpose, followed by conditional behavior and parameter details in two efficient sentences. Every sentence adds necessary information without redundancy, making it appropriately sized and well-structured for quick comprehension.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Completeness3/5
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
Given the complexity of a creation tool with 6 parameters, no annotations, and no output schema, the description is moderately complete. It covers key behavioral aspects and parameter semantics but lacks details on permissions, error handling, and return values. This leaves the agent with incomplete operational context, though it meets minimum viability for basic use.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Parameters4/5
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
Schema description coverage is high (83%), so the baseline is 3. The description adds value by clarifying the semantics of message_id (anchoring behavior) and auto_archive_duration (specific minute values), which complements the schema. However, it does not address parameters like type or invitable beyond what the schema already describes, keeping it from a perfect score.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Purpose5/5
Does the description clearly state what the tool does and how it differs from similar tools?
The description clearly states the specific action ('Create a thread') and distinguishes between two modes: creating from a message or standalone. It explicitly mentions the resource (thread) and the conditional behavior based on message_id, which differentiates it from sibling tools like discord_send_message or discord_list_active_threads.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Usage Guidelines4/5
Does the description explain when to use this tool, when not to, or what alternatives exist?
The description provides clear context on when to use different modes (with or without message_id) and mentions auto_archive_duration options. However, it does not explicitly state when to use this tool versus alternatives like discord_send_message for general messaging or discord_list_active_threads for viewing threads, nor does it mention prerequisites or exclusions.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Behavior3/5
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
With no annotations provided, the description carries the full burden. It discloses that editing is limited to bot messages only, which is a crucial behavioral constraint. However, it doesn't mention authentication requirements, rate limits, or what happens when editing fails, leaving some behavioral aspects unclear.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Conciseness5/5
Is the description appropriately sized, front-loaded, and free of redundancy?
Two sentences with zero waste: the first states the purpose and scope, the second adds a critical exclusion. Every word earns its place, and the most important information (what it does and what it doesn't do) is front-loaded.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Completeness3/5
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
For a mutation tool with no annotations and no output schema, the description provides essential context about limitations (bot messages only) but lacks details on error conditions, return values, or side effects. Given the complexity of editing messages in Discord, more behavioral context would be helpful.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Parameters3/5
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 mentions that you can 'edit content and embeds,' which maps to two of the four parameters (content, embeds), adding meaning beyond the bare schema. However, it doesn't explain channel_id or message_id parameters, leaving half the parameters without semantic context.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Purpose5/5
Does the description clearly state what the tool does and how it differs from similar tools?
The description clearly states the specific action ('Edit a message') with the resource ('the bot previously sent'), distinguishing it from sibling tools like discord_delete_message or discord_send_message by specifying it's for editing existing bot messages only.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Usage Guidelines5/5
Does the description explain when to use this tool, when not to, or what alternatives exist?
It explicitly states when to use this tool ('Edit a message the bot previously sent') and when not to use it ('Cannot edit other users' messages'), providing clear boundaries that differentiate it from alternatives like discord_send_message for new messages.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Behavior4/5
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
With no annotations provided, the description carries full burden and does well by disclosing key behavioral traits: the action is destructive (removal), has permission requirements, and mentions the user can rejoin via invite. It doesn't cover rate limits, error conditions, or response format, but provides essential context for a mutation operation.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Conciseness5/5
Is the description appropriately sized, front-loaded, and free of redundancy?
Two concise sentences with zero waste: first states the core action, second adds crucial context (rejoin possibility and permission requirement). Every word earns its place, and information is front-loaded appropriately.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Completeness3/5
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
For a destructive mutation tool with 3 parameters, 0% schema coverage, and no output schema, the description provides good behavioral context but lacks parameter documentation and return value information. It's adequate for basic understanding but leaves gaps for proper implementation.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Parameters3/5
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 implies parameters (guild, user, reason through 'Remove a user') but doesn't explicitly name or explain them. The description adds some meaning about the action's purpose but doesn't fully document the 3 parameters beyond what's inferable from the tool name.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Purpose5/5
Does the description clearly state what the tool does and how it differs from similar tools?
The description clearly states the specific action ('Remove a user from the guild') and resource ('user'), distinguishing it from siblings like discord_timeout_user (temporary restriction) or discord_remove_role (role removal). It uses precise terminology that matches Discord's API concepts.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Usage Guidelines4/5
Does the description explain when to use this tool, when not to, or what alternatives exist?
The description explicitly states when to use this tool ('Remove a user from the guild') and includes a prerequisite ('Requires Kick Members permission'). However, it doesn't explicitly contrast with alternatives like discord_timeout_user or explain when kicking vs. other moderation actions is appropriate.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Behavior4/5
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 effectively describes key behavioral traits: the destructive nature of deletion, permission requirements (Manage Messages for others, self-deletion allowed), and the audit log implication via the 'reason' parameter. This covers safety and authorization aspects well, though it lacks details on error handling 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.
Conciseness5/5
Is the description appropriately sized, front-loaded, and free of redundancy?
The description is front-loaded with the core purpose in the first sentence, followed by essential usage context in the second. Both sentences earn their place by providing critical information without redundancy, making it efficient and well-structured.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Completeness4/5
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
Given the tool's complexity (destructive operation with permission nuances), no annotations, and no output schema, the description is reasonably complete. It covers the action, permissions, and audit log context, but lacks details on return values or error cases, which would enhance completeness for a deletion tool.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Parameters3/5
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
Schema description coverage is 33% (only 'reason' has a description), and the description does not add meaning for the undocumented parameters 'channel_id' and 'message_id'. It implies the 'reason' parameter's purpose (audit log) but does not elaborate beyond what the schema provides. With low coverage, the description compensates minimally, meeting the baseline for partial parameter information.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Purpose5/5
Does the description clearly state what the tool does and how it differs from similar tools?
The description clearly states the specific action ('Delete a single message') and resource ('message'), distinguishing it from sibling tools like 'discord_bulk_delete_messages' (which handles multiple messages) and 'discord_edit_message' (which modifies rather than deletes). The verb 'Delete' is precise and unambiguous.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Usage Guidelines4/5
Does the description explain when to use this tool, when not to, or what alternatives exist?
The description provides clear context for when to use this tool by specifying permission requirements ('Requires Manage Messages for other users' messages; bot can always delete its own'), which helps differentiate it from alternatives like 'discord_bulk_delete_messages' for batch operations. However, it does not explicitly state when NOT to use it or name specific alternatives beyond implied distinctions.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Behavior4/5
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 key behavioral traits: pagination support, default limit (25), and maximum limit (100), which are crucial for usage. However, it does not mention rate limits, permissions required, or error conditions, leaving some gaps in transparency.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Conciseness5/5
Is the description appropriately sized, front-loaded, and free of redundancy?
The description is a single, well-structured sentence that front-loads the core purpose and efficiently adds pagination details. Every word earns its place, with no redundancy or unnecessary elaboration, making it highly concise and clear.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Completeness4/5
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
Given no annotations, no output schema, and moderate complexity (5 parameters, 3 required), the description is fairly complete. It covers the tool's purpose, pagination behavior, and key parameter details, but lacks information on return values, error handling, or authentication needs, which could be helpful for an agent.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Parameters4/5
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
Schema description coverage is low (40%), with only 'limit' and 'after' having descriptions. The description adds value by clarifying that 'limit' is for pagination with a default of 25 and max of 100, which compensates for the low coverage. It does not explain 'channel_id', 'message_id', or 'emoji' beyond their names, but the tool's purpose implicitly defines their roles.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Purpose5/5
Does the description clearly state what the tool does and how it differs from similar tools?
The description clearly states the verb ('List users') and resource ('who reacted with a specific emoji on a message'), making the purpose specific and unambiguous. It distinguishes from siblings like discord_add_reaction (adds reactions) and discord_remove_reaction (removes reactions) by focusing on listing users, not modifying reactions.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Usage Guidelines3/5
Does the description explain when to use this tool, when not to, or what alternatives exist?
The description implies usage when needing to see who reacted with a particular emoji, but does not explicitly state when to use this tool versus alternatives like discord_get_message (which might include reaction data) or other listing tools. No exclusions or prerequisites are mentioned, leaving some ambiguity for the agent.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Behavior4/5
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 effectively describes key behaviors: it's a read operation (implied by 'List'), requires specific permissions ('Server Members privileged intent'), and supports pagination ('Paginate with `after` cursor'). However, it lacks details on rate limits, error conditions, or response format.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Conciseness5/5
Is the description appropriately sized, front-loaded, and free of redundancy?
The description is front-loaded with the core purpose, followed by essential details (pagination and permission requirement) in two concise sentences. Every sentence earns its place with no wasted words, making it highly efficient and well-structured.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Completeness4/5
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
Given the tool's moderate complexity (3 parameters, no output schema, no annotations), the description is mostly complete. It covers purpose, pagination, and permissions, but lacks details on response format, error handling, or rate limits. For a list operation with no output schema, this is adequate but not exhaustive.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Parameters3/5
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
Schema description coverage is 67% (2 out of 3 parameters have descriptions). The description adds value by explaining the pagination mechanism ('after cursor (last user ID)'), which clarifies the schema's 'after' parameter. However, it does not provide additional context for 'guild_id' or 'limit' beyond what the schema offers, meeting the baseline for moderate coverage.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Purpose5/5
Does the description clearly state what the tool does and how it differs from similar tools?
The description clearly states the verb ('List') and resource ('members of a guild'), making the purpose specific and unambiguous. It distinguishes from siblings like 'discord_get_member' (singular) and 'discord_list_guilds' (different resource), providing clear differentiation.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Usage Guidelines4/5
Does the description explain when to use this tool, when not to, or what alternatives exist?
The description explicitly states when to use this tool ('List members of a guild') and provides context for pagination, but does not specify when not to use it or name alternatives among siblings. It mentions a prerequisite ('Requires the Server Members privileged intent on the bot'), which is helpful guidance.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Behavior4/5
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 effectively adds context beyond basic functionality by specifying permission requirements ('Requires Manage Messages') and a key constraint ('Channels max 50 pinned messages'), which are crucial for understanding limitations and prerequisites. It does not cover response format or error handling, but provides essential operational details.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Conciseness5/5
Is the description appropriately sized, front-loaded, and free of redundancy?
The description is extremely concise and front-loaded, consisting of two sentences that efficiently convey purpose, requirements, and a critical constraint without any wasted words. Every sentence adds value, making it easy to parse and understand quickly.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Completeness4/5
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
Given the tool's moderate complexity (a mutation operation with permissions and constraints), no annotations, no output schema, and low schema coverage, the description is relatively complete. It covers the core action, prerequisites, and a key limitation, but lacks details on parameters, return values, or error cases. For a tool with these gaps, it provides sufficient context to use it correctly in most cases.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Parameters3/5
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
Schema description coverage is 0%, so the schema provides no parameter details. The description does not mention any parameters explicitly, failing to compensate for the coverage gap. However, the purpose implies parameters like channel_id and message_id, and the constraint about max pinned messages hints at potential outcomes, offering minimal semantic context. With 3 parameters and no schema descriptions, this is a baseline score.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Purpose5/5
Does the description clearly state what the tool does and how it differs from similar tools?
The description clearly states the action ('Pin a message') and resource ('in a channel'), using a specific verb and target. It distinguishes from siblings like 'discord_unpin_message' by specifying the opposite operation, and from other message-related tools like 'discord_edit_message' or 'discord_delete_message' by focusing on pinning.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Usage Guidelines4/5
Does the description explain when to use this tool, when not to, or what alternatives exist?
The description provides explicit context for when to use it ('Pin a message in a channel') and includes prerequisites ('Requires Manage Messages'), which helps guide usage. However, it does not explicitly state when not to use it or name alternatives (e.g., 'discord_unpin_message' for unpinning), missing full sibling differentiation.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Behavior4/5
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 effectively describes key behavioral traits: it's a mutation operation (implied by 'Add'), requires specific permissions ('Manage Roles'), and has a hierarchical constraint ('target role must be below the bot's highest role'). However, it doesn't mention rate limits, error conditions, or response format, leaving some gaps.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Conciseness5/5
Is the description appropriately sized, front-loaded, and free of redundancy?
The description is front-loaded with the core purpose in the first clause, followed by essential prerequisites. Both sentences earn their place by providing critical information without redundancy or fluff, making it highly efficient.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Completeness3/5
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
Given no annotations, no output schema, and 0% schema description coverage for a 4-parameter mutation tool, the description is moderately complete. It covers purpose, usage context, and key constraints, but lacks details on parameter semantics, return values, error handling, or side effects, which are important for a tool with permissions and hierarchical rules.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Parameters3/5
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 for undocumented parameters. It implicitly references guild_id, user_id, and role_id through context ('guild member', 'role'), but doesn't explain parameter meanings, formats, or the optional 'reason' parameter. The description adds minimal semantic value beyond what's inferable from parameter names.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Purpose5/5
Does the description clearly state what the tool does and how it differs from similar tools?
The description clearly states the specific action ('Add a role') and target ('to a guild member'), distinguishing it from sibling tools like discord_remove_role, discord_list_roles, or discord_kick_user. It precisely identifies the verb and resource without ambiguity.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Usage Guidelines5/5
Does the description explain when to use this tool, when not to, or what alternatives exist?
The description explicitly states when to use this tool ('Add a role to a guild member') and provides critical prerequisites: 'Requires Manage Roles and the target role must be below the bot's highest role.' This gives clear context for usage versus alternatives like discord_remove_role or other member management tools.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Behavior4/5
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 effectively describes the action (adding a reaction), specifies the actor (the bot), and outlines permission requirements. It also clarifies the emoji format, which is crucial for correct usage. However, it lacks details on rate limits, error conditions, or response format, leaving some behavioral aspects uncovered.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Conciseness5/5
Is the description appropriately sized, front-loaded, and free of redundancy?
The description is front-loaded with the core purpose, followed by essential details (emoji format and permissions) in a single, efficient sentence. Every part earns its place, with no redundant or verbose language, making it highly concise and well-structured.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Completeness4/5
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
Given the tool's moderate complexity (3 parameters, no output schema, no annotations), the description is mostly complete. It covers the action, actor, parameters, and prerequisites. However, it lacks information on return values or error handling, which would be beneficial for full contextual understanding, especially without an output schema.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Parameters4/5
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
Schema description coverage is low (33%), with only the 'emoji' parameter documented in the schema. The description compensates by explaining the emoji format ('Unicode glyph or custom-emoji string') and implying the need for channel_id and message_id to target a specific message. This adds meaningful context beyond the bare schema, though it could further clarify parameter relationships or constraints.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Purpose5/5
Does the description clearly state what the tool does and how it differs from similar tools?
The description clearly states the specific action ('Add a reaction from the bot to a message') and resource ('message'), distinguishing it from sibling tools like discord_remove_reaction (which removes reactions) or discord_get_reactions (which retrieves them). The verb 'Add' is precise and the target 'reaction from the bot' is well-defined.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Usage Guidelines4/5
Does the description explain when to use this tool, when not to, or what alternatives exist?
The description provides clear context by specifying prerequisites ('Requires Add Reactions + Read Message History'), which helps determine when the tool can be used. However, it does not explicitly state when to use this tool versus alternatives like discord_remove_reaction or discord_get_reactions, nor does it mention exclusions or edge cases.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Behavior4/5
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 effectively describes key constraints: the 2-100 message range, the 14-day age limit, and the permission requirement. However, it does not mention potential side effects (e.g., whether deletions are logged or reversible) or error handling, leaving some behavioral aspects unclear.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Conciseness5/5
Is the description appropriately sized, front-loaded, and free of redundancy?
The description is front-loaded with the core functionality, followed by constraints and usage context. All three sentences are necessary and contribute value without redundancy. It is efficiently structured and appropriately sized for the tool's complexity.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Completeness4/5
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
Given the tool's moderate complexity (3 parameters, no output schema, no annotations), the description covers essential aspects like purpose, constraints, and permissions. However, it lacks details on return values or error cases, which would enhance completeness. It is mostly adequate but has minor gaps.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Parameters4/5
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
Schema description coverage is low (33%), with only 'message_ids' documented. The description compensates by clarifying the purpose of bulk deletion and the 2-100 range, which adds meaning beyond the schema. However, it does not explain 'channel_id' or 'reason' parameters, so some semantic gaps remain.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Purpose5/5
Does the description clearly state what the tool does and how it differs from similar tools?
The description clearly states the specific action ('Bulk delete'), resource ('messages'), and scope ('from a channel'), distinguishing it from the sibling 'discord_delete_message' which presumably handles single deletions. The verb+resource combination is precise and unambiguous.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Usage Guidelines4/5
Does the description explain when to use this tool, when not to, or what alternatives exist?
The description provides clear context for when to use this tool ('Useful for raid cleanup') and mentions prerequisites ('Requires Manage Messages permission'), but does not explicitly state when NOT to use it or name alternatives (e.g., 'discord_delete_message' for single deletions). The guidance is helpful but not fully comparative.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Behavior4/5
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 effectively describes the tool's behavior (triggers a typing indicator for ~10 seconds) and its purpose (user feedback during processing). However, it lacks details on potential limitations like rate limits, permissions required, or error conditions, which would be helpful 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.
Conciseness5/5
Is the description appropriately sized, front-loaded, and free of redundancy?
The description is highly concise and front-loaded, with two sentences that each serve a clear purpose: the first defines the action and duration, and the second provides usage guidance. There is no wasted text, making it efficient for an AI agent to parse.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Completeness4/5
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
Given the tool's low complexity (1 parameter, no output schema, no annotations), the description is mostly complete for its purpose. It explains what the tool does, when to use it, and behavioral traits. However, it lacks parameter details and does not cover potential side effects or error handling, which are minor gaps for such a simple tool.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Parameters3/5
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
The input schema has 0% description coverage, but the description does not mention the 'channel_id' parameter at all. While the tool has only one parameter, the description fails to add any semantic context beyond what the schema's property name implies, missing an opportunity to clarify what channel_id represents (e.g., a Discord channel ID).
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Purpose5/5
Does the description clearly state what the tool does and how it differs from similar tools?
The description clearly states the specific action ('Trigger the "bot is typing…" indicator') and resource ('in a channel'), distinguishing it from siblings like discord_send_message. It explicitly mentions the duration ('for about 10 seconds'), which adds precision beyond a generic typing indicator.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Usage Guidelines5/5
Does the description explain when to use this tool, when not to, or what alternatives exist?
The description provides explicit guidance on when to use this tool ('Useful before sending a long-form response so users know the bot is working'), including a specific scenario and alternative context (i.e., use it before discord_send_message for long responses). This clearly differentiates it from other messaging-related tools.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Behavior4/5
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 effectively describes key behavioral traits: the tool's behavior changes based on the presence of user_id (removing bot's own vs. user's reaction) and mentions a permission requirement (Manage Messages for user-specific removal). However, it lacks details on error handling, rate limits, or response format, leaving some gaps.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Conciseness5/5
Is the description appropriately sized, front-loaded, and free of redundancy?
The description is front-loaded with the core action and efficiently uses two sentences to cover key usage rules and permissions. Every sentence adds value—no wasted words—making it highly concise and well-structured for quick comprehension.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Completeness4/5
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
Given the complexity (a mutation tool with permission nuances), no annotations, and no output schema, the description does a good job covering essential aspects like purpose, usage, and behavioral traits. However, it omits details on return values, error cases, or side effects, which could be important for full agent understanding in this context.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Parameters4/5
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
Schema description coverage is low at 25%, with only user_id having a description. The description compensates by explaining the semantics of user_id (optional, specifies whose reaction to remove, with implications for permissions) and implies the purpose of other parameters (channel_id, message_id, emoji for targeting). It adds meaningful context beyond the schema, though not exhaustive for all parameters.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Purpose5/5
Does the description clearly state what the tool does and how it differs from similar tools?
The description clearly states the specific action ('Remove a reaction') and distinguishes it from siblings like discord_add_reaction and discord_delete_message by focusing on reaction removal rather than addition or message deletion. It specifies the resource (a reaction) and the operation (removal), making the purpose explicit and distinct.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Usage Guidelines5/5
Does the description explain when to use this tool, when not to, or what alternatives exist?
The description provides explicit guidance on when to use this tool vs. alternatives: it specifies that without user_id, it removes the bot's own reaction, and with user_id, it removes a specific user's reaction (requiring Manage Messages). This clearly differentiates usage scenarios and prerequisites, helping the agent choose correctly based on context.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Behavior4/5
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
With no annotations provided, the description carries the full burden and effectively discloses key behavioral traits: it specifies the action is a timeout (not read-only), mentions the 28-day maximum duration, explains how to clear a timeout, and states the required permission. It lacks details on error handling or response format, but covers essential 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.
Conciseness5/5
Is the description appropriately sized, front-loaded, and free of redundancy?
The description is front-loaded with the core purpose, followed by key details in a logical flow: effects, duration, special case, and permission requirement. Every sentence adds value with no wasted words, making it highly efficient and easy to parse.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Completeness4/5
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
Given no annotations and no output schema, the description does well by covering purpose, usage, key parameters, and permissions. It could improve by mentioning error cases or response structure, but it's largely complete for a mutation tool with moderate complexity.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Parameters4/5
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
Schema description coverage is low at 25%, but the description adds significant meaning: it explains that duration_seconds=0 clears a timeout and notes the 28-day max, which clarifies beyond the schema's basic description. It doesn't detail guild_id or user_id semantics, but compensates well for the coverage gap.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Purpose5/5
Does the description clearly state what the tool does and how it differs from similar tools?
The description clearly states the specific action ('Timeout a user') and the effects ('they cannot send messages, react, or join voice'), distinguishing it from sibling tools like discord_kick_user or discord_remove_role by specifying timeout functionality rather than removal or role management.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Usage Guidelines5/5
Does the description explain when to use this tool, when not to, or what alternatives exist?
It provides explicit guidance on when to use this tool ('Timeout a user') and when not to (e.g., for removal use discord_kick_user), including prerequisites ('Requires Moderate Members permission') and special cases ('Pass duration_seconds=0 to remove an existing timeout').
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.

GitHub Badge

Glama performs regular codebase and documentation scans to:

Confirm that the MCP server is working as expected.
Confirm that there are no obvious security issues.
Evaluate tool definition quality.

Our badge communicates server capabilities, safety, and installation instructions.

Card Badge

Copy to your README.md:

[![mcp-discord MCP server](https://glama.ai/mcp/servers/devli13/mcp-discord/badges/card.svg)](https://glama.ai/mcp/servers/devli13/mcp-discord)

Score Badge

Copy to your README.md:

[![mcp-discord MCP server](https://glama.ai/mcp/servers/devli13/mcp-discord/badges/score.svg)](https://glama.ai/mcp/servers/devli13/mcp-discord)

Latest Blog Posts

Who's Calling? MCP Hosts Are an Identity Blind Spot (And the Spec Knows It)
By Om-Shree-0709 on July 25, 2026.
mcp
Agent Identity
OAuth 2.1
Your AI Chatbot Just Exposed Your CEO's Salary to an Intern
By Om-Shree-0709 on July 2, 2026.
Agent Identity
MCP Security
OAuth Delegation
Why MCP Servers Need Execution Sandboxing (And Why Your Current Stack Isn't Enough)
By Om-Shree-0709 on June 30, 2026.
Agentic Ai
Prompt Injection
WebAssembly

MCP directory API

We provide all the information about MCP servers via our MCP API.

curl -X GET 'https://glama.ai/api/mcp/v1/servers/devli13/mcp-discord'

If you have feedback or need assistance with the MCP directory API, please join our Discord server