zulip

by zulip

Overview Schema Related Servers Score Discussions

Python

Remote

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, but some overlap exists: 'reply' and 'send_message' both send messages, though 'reply' is for the current context and 'send_message' is for a specified stream/topic. 'edit_message' and 'resolve_topic' both modify content, but 'edit_message' is for a single message and 'resolve_topic' is for topic renaming. Descriptions help clarify these boundaries, but an agent might occasionally misselect between similar tools.
Naming Consistency5/5
Tool names follow a consistent snake_case pattern with clear verb_noun structures throughout, such as 'add_reaction', 'edit_message', 'get_messages', 'send_direct_message', and 'upload_file'. There are no deviations in naming conventions, making the set predictable and easy to understand.
Tool Count3/5
With 27 tools, the count feels heavy for a messaging server, though it covers a wide range of operations from message handling to user management and security. While comprehensive, it may overwhelm agents with too many options, especially given the overlapping purposes noted in disambiguation. A more streamlined set could improve usability without losing functionality.
Completeness5/5
The tool set provides complete coverage for Zulip's domain, including CRUD operations for messages (send, edit, delete via move/resolve), reactions, streams, topics, users, files, and sessions. It also includes advanced features like security verification, typing indicators, and context management, ensuring agents can handle all typical workflows without dead ends.
Average 4/5 across 27 of 27 tools scored. Lowest: 2.7/5.
See the Tool Scores section below for per-tool breakdowns.
- No community issues in the last 6 months
- 12 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 Apache 2.0.
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.
This repository includes a glama.json configuration file.
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 the full burden of behavioral disclosure. It mentions that it returns a confirmation with a message ID, which is helpful, but doesn't cover critical aspects like whether this is a read-only or mutating operation, authentication requirements, rate limits, error conditions, or what 'current session context' entails behaviorally. The description adds minimal behavioral context beyond the basic operation.
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 appropriately sized and front-loaded with the core purpose. It uses a structured format with 'Args:' and 'Returns:' sections, which enhances clarity. However, the first sentence 'Reply in the current session context.' is somewhat vague and could be more precise, slightly reducing efficiency.
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 has one parameter, no annotations, and an output schema (which handles return values), the description is minimally adequate. It explains the parameter and return confirmation, but gaps remain in behavioral transparency and usage guidelines. For a simple tool, it covers basics but lacks depth in contextual details like session management or tool differentiation.
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 provides a brief explanation for the single parameter 'content' ('The message content (supports Zulip markdown)'), which adds useful semantic information about markdown support not evident from the schema. However, with only one parameter and partial coverage, this meets the baseline expectation without fully compensating for the lack of schema descriptions.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Purpose3/5
Does the description clearly state what the tool does and how it differs from similar tools?
The description states 'Reply in the current session context' which provides a basic verb+resource combination, but it's vague about what 'current session context' means and doesn't distinguish this tool from sibling tools like 'send_message' or 'send_direct_message'. The purpose is understandable but lacks specificity about the exact nature of the reply operation.
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 is provided on when to use this tool versus alternatives like 'send_message' or 'send_direct_message'. The phrase 'current session context' implies some contextual usage but doesn't specify prerequisites, exclusions, or clear differentiation from sibling tools. This leaves the agent without proper selection criteria.
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 'recent topics' and a default limit, but doesn't cover critical aspects like pagination, error handling, authentication needs, rate limits, or what 'recent' means (e.g., time frame). For a read operation with no annotation coverage, this leaves significant gaps in understanding the tool's behavior.
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 appropriately sized and front-loaded: the first sentence states the purpose clearly, followed by a brief 'Args' section. There's no wasted text, and it's easy to scan. It could be slightly more structured (e.g., bullet points), but overall, it's efficient and well-organized.
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 (2 parameters, no annotations, but has an output schema), the description is partially complete. It covers the basic purpose and parameters, but lacks usage guidelines and detailed behavioral context. The presence of an output schema means return values are documented elsewhere, so the description doesn't need to explain them, but it still falls short in other areas for a tool with no annotations.
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 description adds basic semantics for both parameters: 'stream' is explained as 'Stream/channel name' and 'limit' as 'Max topics to return (default 20)'. However, schema description coverage is 0%, so the schema provides no additional details. The description compensates somewhat by clarifying parameter roles, but it doesn't go into depth (e.g., format for 'stream', constraints for 'limit'), keeping it at a baseline level.
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: 'Get recent topics in a stream.' It specifies the verb ('Get') and resource ('recent topics in a stream'), making it easy to understand what the tool does. However, it doesn't explicitly differentiate from sibling tools like 'get_messages' or 'resolve_topic', which could also involve topics, so it doesn't reach the highest score.
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 sibling tools like 'get_messages' (which might include topics) or 'resolve_topic', nor does it specify prerequisites or exclusions. The lack of context leaves the agent to infer usage, which is minimal guidance.
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 it's a read operation ('Get'), but doesn't mention permissions, error handling (e.g., what happens if the ID doesn't exist), rate limits, 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.
Conciseness4/5
Is the description appropriately sized, front-loaded, and free of redundancy?
The description is appropriately concise with two sentences: one stating the purpose and another explaining the parameter. It's front-loaded with the core function. The 'Args:' section is slightly redundant but still 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 has an output schema (which handles return values) and only one parameter, the description is minimally adequate. However, with no annotations and incomplete behavioral details, it doesn't fully prepare an agent for safe and effective use, especially regarding error cases or permissions.
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 for the single parameter ('message_id: The message ID'), which is helpful since schema description coverage is 0%. However, it doesn't specify format constraints (e.g., integer range) or where to find message IDs, 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 ('Get') and resource ('a specific message by its ID'), making the purpose unambiguous. However, it doesn't explicitly differentiate from sibling tools like 'get_messages' (plural) or 'verify_message', which could cause confusion about when to use this versus those alternatives.
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 guidance is provided on when to use this tool versus alternatives like 'get_messages' or 'verify_message'. The description only states what it does, not when it should be selected over other message-related tools in the sibling list.
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 full burden for behavioral disclosure. It states this sends messages but doesn't mention permissions required, rate limits, whether messages are editable/deletable after sending, or what happens with invalid recipients. The description is minimal and lacks important 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 efficiently structured with a clear purpose statement followed by parameter explanations. Every sentence adds value, and there's no redundant information. The two-sentence format with parameter details is appropriately concise.
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 has an output schema (which handles return values) and only 2 parameters with basic types, the description provides adequate context for a simple messaging tool. However, as a mutation tool with no annotations, it should ideally mention more about behavioral aspects like permissions or error handling to be fully complete.
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%, but the description adds basic semantics for both parameters: 'recipients' as email addresses in a list and 'content' supporting Zulip markdown. This compensates somewhat for the schema gap, though it doesn't provide format examples beyond the basic array structure or explain markdown limitations.
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 ('Send') and resource ('direct message to one or more users'), making the purpose unambiguous. However, it doesn't explicitly differentiate from the sibling 'send_message' tool, which might handle different message types like stream messages.
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 like 'send_message' or 'reply'. It mentions sending to 'one or more users' but doesn't clarify if this is for private conversations only or how it differs from other messaging tools in the sibling list.
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 full burden for behavioral disclosure. It only states what the tool does at a high level without mentioning permissions needed, rate limits, pagination behavior, error conditions, or what the output contains. This leaves significant gaps for an agent to understand how to use it effectively.
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 with just two sentences that directly state the purpose and document the parameter. Every word earns its place, and the structure is front-loaded with the core functionality followed by parameter details.
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 has an output schema (which handles return values) and only one parameter, the description covers the basics. However, as a read operation with no annotations, it should ideally mention more about behavioral aspects like what 'members' includes or any limitations, making it adequate but with clear 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?
The description includes an 'Args' section that documents the single parameter 'stream' and explains it's the 'Stream/channel name.' Since schema description coverage is 0% and there's only one parameter, this adequately compensates by providing the necessary semantic meaning beyond the bare schema type.
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 ('Get') and resource ('members of a stream/channel'), making the purpose immediately understandable. However, it doesn't specifically differentiate from sibling tools like 'get_user_info' or 'get_stream_topics' that also retrieve information about streams, which prevents a perfect score.
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. There's no mention of prerequisites, when this tool is appropriate compared to similar tools like 'get_user_info' or 'get_stream_topics', or any context about its role in workflows.
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 a read operation ('Get') but lacks details on permissions, rate limits, response format, or whether it returns all subscriptions or a filtered subset. This is a significant gap for a tool with zero 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 directly states the tool's purpose without any unnecessary words. It is front-loaded and wastes no space, making it ideal 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 tool has no parameters, annotations, or complex schema, and an output schema exists, the description is minimally adequate. However, it lacks behavioral context (e.g., what the output contains) and usage differentiation from siblings, leaving room for improvement despite the low 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?
The input schema has 0 parameters with 100% coverage, so the schema fully documents the absence of inputs. The description adds no parameter information, which is appropriate here, and the baseline for 0 parameters is 4, as there's nothing to compensate for.
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 ('Get') and the resource ('streams the bot is subscribed to'), making the purpose immediately understandable. However, it doesn't differentiate from sibling tools like 'list_streams' or 'get_stream_members', which could have overlapping functionality, preventing a perfect score.
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 such as 'list_streams' or 'get_stream_members'. There is no mention of prerequisites, context, or exclusions, leaving the agent to infer usage based on 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 full burden but only states what the tool does, not how it behaves. It lacks details on permissions needed (e.g., admin vs. user access), pagination, rate limits, or output format (though an output schema exists). This is a significant gap for a tool with zero 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 action ('List all available Zulip streams/channels') and adds clarifying scope ('public and private'). There is zero wasted text, 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.
Completeness3/5
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
Given the tool's simplicity (0 parameters, output schema provided), the description is minimally adequate but lacks behavioral context like access requirements or output characteristics. It covers the basic purpose but doesn't fully compensate for the absence of annotations, leaving gaps in usage understanding.
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 0 parameters with 100% coverage, so no parameter documentation is needed. The description doesn't add parameter details, but this is appropriate given the schema's completeness, warranting a baseline score above 3 for this context.
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 ('Zulip streams/channels') with scope ('all available...public and private'), making the purpose unambiguous. It doesn't explicitly differentiate from sibling tools like 'get_subscribed_streams' or 'get_stream_topics', which prevents a perfect score.
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 like 'get_subscribed_streams' (which might list only user-subscribed streams) or 'get_stream_topics' (which focuses on topics within streams). There's no mention of prerequisites, exclusions, or comparative contexts.
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 that the tool returns 'all available profile data including custom fields,' which adds some context about output richness. However, it lacks details on permissions, rate limits, error handling, or whether this is a read-only operation (implied but not stated). For a tool with no annotations, this is insufficient.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Conciseness4/5
Is the description appropriately sized, front-loaded, and free of redundancy?
The description is appropriately sized and front-loaded: the first sentence states the core purpose, followed by details on return data and usage. The 'Args' section is redundant with the schema but adds clarity. There's minimal waste, though the phone number example could be more integrated.
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) and the presence of an output schema (which handles return values), the description is reasonably complete. It covers the purpose, parameter semantics, and output scope. However, with no annotations, it could better address behavioral aspects like safety or limitations.
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 0%, so the description must compensate. It adds meaning by specifying that the 'email' parameter is 'The user's email address,' which clarifies the expected input format beyond the schema's basic string type. Since there's only one parameter, this is adequate, but it doesn't cover edge cases like invalid emails, so it's not a perfect 5.
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: 'Get information about a Zulip user, including their full profile.' It specifies the verb ('Get') and resource ('Zulip user'), and distinguishes it from siblings like 'resolve_name' or 'get_message_by_id' by focusing on user profiles rather than messages or streams. However, it doesn't explicitly contrast with all siblings, so it's not a perfect 5.
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 guidance: 'Use this tool to look up someone's phone number.' This suggests a specific use case, but it doesn't explicitly state when to use this tool versus alternatives like 'resolve_name' (which might handle user identification differently) or when not to use it. No clear exclusions or comparisons with siblings 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 describes the action ('fetch... and save it to a temp file'), implying a read operation that creates a temporary file, but doesn't detail permissions, rate limits, file cleanup, or error handling. This provides basic context but lacks depth for a tool with potential side effects, warranting an average score.
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 a concise 'Args' section that adds necessary detail without redundancy. Every sentence earns its place, and the structure is clear and efficient, making it easy for an agent to parse 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 (single parameter, no annotations, but with an output schema), the description is reasonably complete. It explains what the tool does and the parameter semantics, and the presence of an output schema means return values need not be described. However, it could improve by addressing behavioral aspects like error conditions or file lifecycle, keeping it from a perfect score.
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 description coverage is 0%, so the description must compensate. It adds meaning by explaining the 'path' parameter as an 'Image path from message content' with an example ('/user_uploads/2/54/abc/image.jpg'), clarifying its source and format beyond the schema's type definition. This effectively covers the single parameter, though it doesn't address edge cases or validation rules.
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 ('image from Zulip'), and specifies the outcome ('save it to a temp file for viewing'). It distinguishes from siblings like 'fetch_file' by focusing specifically on images. However, it doesn't explicitly contrast with 'upload_file' or other file-related tools, keeping it at 4 rather than 5.
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 like 'fetch_file' or 'upload_file'. It mentions the source ('from Zulip') but doesn't specify prerequisites, exclusions, or contextual cues for selection among sibling tools. This lack of comparative usage advice results in a minimal score.
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 but does not cover important aspects such as required permissions, whether the operation is reversible, potential side effects (e.g., notifications), or error handling (e.g., invalid message_id or emoji_name). The description lacks behavioral context beyond the basic 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 highly concise and well-structured: a clear purpose statement followed by parameter explanations in a simple 'Args:' section. Every sentence adds value without redundancy, and the information is front-loaded for quick understanding.
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 that there is an output schema (which handles return values), the description covers the basic operation and parameters adequately. However, as a mutation tool with no annotations, it lacks details on permissions, side effects, or error cases, which are important for safe and effective use. The description is minimally complete but has clear gaps in behavioral 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?
The description adds meaningful semantics for both parameters: 'message_id' is explained as 'The message ID', and 'emoji_name' is clarified with an example ('e.g. "thumbs_up", "check"') and formatting guidance ('without colons'). This compensates well for the 0% schema description coverage, providing essential context that the schema alone does not.
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 an emoji reaction') and resource ('from a message'), distinguishing it from sibling tools like 'add_reaction' (which adds reactions) and 'edit_message' (which modifies message content). The verb 'remove' 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 Guidelines3/5
Does the description explain when to use this tool, when not to, or what alternatives exist?
The description implies usage by specifying the action, but does not explicitly state when to use this tool versus alternatives like 'edit_message' or 'add_reaction'. No guidance is provided on prerequisites, error conditions, or contextual constraints beyond the basic parameters.
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 for behavioral disclosure. While 'Add an emoji reaction' implies a write operation, it doesn't specify permissions required, whether reactions are reversible (though 'remove_reaction' sibling suggests they are), rate limits, or what the output contains. The description adds minimal behavioral context beyond the basic action.
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 efficiently structured with a clear purpose statement followed by parameter explanations. Both sentences earn their place by providing critical information. It could be slightly more concise by integrating the parameter details into the main sentence, but overall it's well-organized and front-loaded.
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 (2 required parameters, no annotations, but with an output schema), the description is reasonably complete. It covers purpose and parameter semantics adequately. The presence of an output schema means return values don't need explanation, though more behavioral context (like permissions or side effects) would improve completeness for a write operation.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Parameters5/5
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
With 0% schema description coverage, the description fully compensates by clearly explaining both parameters: 'message_id' identifies the target message, and 'emoji_name' specifies the emoji format ('without colons') with concrete examples ('thumbs_up', 'check'). This adds essential meaning not present in the bare schema.
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 an emoji reaction') and target resource ('to a message'), using precise verb+resource language. It distinguishes this tool from sibling tools like 'remove_reaction' (which does the opposite) and 'edit_message'/'send_message' (which modify message content rather than 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 context through the action itself (adding reactions to messages) but provides no explicit guidance on when to use this tool versus alternatives like 'edit_message' for modifying content or 'remove_reaction' for undoing reactions. No prerequisites or exclusions are mentioned.
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 mentions saving files locally and using a temp dir as default, but fails to address critical aspects like authentication requirements, rate limits, error handling (e.g., invalid paths), file size constraints, or whether the operation is idempotent. This leaves significant gaps for an agent to understand operational risks.
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 efficiently structured with a clear purpose statement followed by concise parameter explanations. Every sentence adds value: the first defines the tool's action, and the two parameter lines provide essential usage details without redundancy. It's front-loaded and wastes no words.
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 (2 parameters, no annotations, but with an output schema), the description is partially complete. It covers the basic operation and parameters but omits behavioral details like error cases or security considerations. The presence of an output schema means return values needn't be explained, but the description should still address more operational context for safe 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 meaningful context beyond the input schema, which has 0% schema description coverage. It explains that 'path' is a 'File path from message content' with an example (e.g., '/user_uploads/...'), and clarifies that 'save_dir' defaults to a temp directory if not provided. This compensates well for the schema's lack of descriptions, though it could detail path validation rules or save_dir permissions.
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 ('fetch any file from Zulip and save it locally') with the resource ('file from Zulip') and distinguishes it from sibling tools like 'fetch_image' (which is image-specific) and 'upload_file' (which performs the opposite operation). The verb 'fetch' combined with 'save locally' provides precise operational intent.
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 implicitly suggests usage for downloading files from Zulip messages, with a clear example path format. However, it lacks explicit guidance on when to use this versus alternatives like 'fetch_image' (for images only) or 'upload_file' (for uploading), and doesn't mention prerequisites or exclusions (e.g., file size limits, permissions).
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 behaviors: the tool uploads files and returns markdown for embedding, with different handling for images (inline display) versus other files (download links). However, it omits details like authentication needs, file size limits, rate limits, or error conditions, which are important 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 structured 'Args' and 'Returns' sections. Every sentence adds value: the first states the action, the second explains the parameter, and the third and fourth detail the return behavior. There is no wasted text, making it highly efficient.
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 with one parameter), no annotations, and an output schema present (which likely covers return values), the description is fairly complete. It explains the purpose, parameter semantics, and return usage. However, it could improve by addressing behavioral aspects like permissions or limitations, slightly reducing 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 schema description coverage is 0%, so the description must compensate. It adds meaning by explaining that 'file_path' is an 'absolute path to the file to upload,' clarifying the parameter's purpose beyond the schema's basic type definition. Since there is only one parameter, this is sufficient to achieve a high score, though it could detail format constraints (e.g., supported file types).
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 ('upload a local file to Zulip') and distinguishes it from sibling tools like 'fetch_file' or 'fetch_image' by focusing on uploading rather than retrieving. It specifies the resource (local file) and destination (Zulip), making the purpose unambiguous.
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 embedding files in messages, but does not explicitly state when to use this tool versus alternatives like 'send_message' for text-only content or 'fetch_file' for retrieving files. It provides context (embedding in messages) but lacks explicit exclusions or comparisons to sibling 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 full burden and adds valuable behavioral context: 'fire-and-forget' indicates asynchronous operation without delivery guarantees, and it specifies that content supports Zulip markdown. It doesn't cover rate limits, authentication requirements, or error conditions, but provides more than minimal behavioral disclosure for a messaging 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?
Perfectly structured with a clear purpose statement upfront, followed by organized parameter explanations. Every sentence earns its place: the first establishes core functionality and behavior, while the parameter descriptions provide essential context without redundancy. No wasted words or unnecessary elaboration.
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 required parameters), no annotations, and the presence of an output schema (which handles return values), the description is reasonably complete. It covers purpose, key behavior, and parameter meanings. However, it lacks information about error conditions, permissions, or how this interacts with sibling tools like 'typing' indicators.
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?
With 0% schema description coverage, the description compensates well by explaining all three parameters: 'stream' as stream/channel name, 'topic' as topic name, and 'content' as message content with Zulip markdown support. This adds meaningful semantics beyond the bare schema types, though it doesn't provide format examples 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 ('Send a message'), the target resource ('to a specific stream and topic'), and the behavioral characteristic ('fire-and-forget'). It distinguishes this from sibling tools like 'send_direct_message', 'reply', and 'edit_message' by specifying the stream/topic destination rather than direct messaging or editing existing messages.
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 context through 'fire-and-forget' (suggesting asynchronous sending without waiting for delivery confirmation) and specifying stream/topic targeting. However, it doesn't explicitly state when to use this versus alternatives like 'send_direct_message' for private messages or 'reply' for threaded responses, nor does it mention prerequisites like required permissions or stream subscription status.
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 tool 'Initialize[s] the session context' and fetches recent messages, which implies read-only behavior, but doesn't explicitly state permissions, rate limits, or whether it modifies server state. It adds some context (one-time use, fetches history) but lacks details on error handling or side effects.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Conciseness4/5
Is the description appropriately sized, front-loaded, and free of redundancy?
The description is well-structured and appropriately sized, with a clear purpose statement followed by Args and Returns sections. Every sentence adds value, though the 'Args' and 'Returns' labels are slightly redundant with schema fields, but they help readability.
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 (session initialization with 3 parameters), no annotations, and an output schema (implied by 'Returns'), the description is fairly complete. It covers purpose, usage, parameters, and return confirmation, though it could benefit from more behavioral details like error cases or session persistence.
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 description coverage is 0%, so the description must compensate. It provides clear semantics for all three parameters: 'stream' as 'The name of the Zulip stream/channel', 'topic' as 'The topic name within the stream', and 'num_messages' as 'Number of recent messages to fetch for context (default 20)'. This adds meaningful context beyond the bare schema types.
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 tool's purpose with specific verbs ('Initialize the session context') and resources ('Zulip stream/channel', 'topic'), distinguishing it from siblings like 'send_message' or 'get_messages' by focusing on session setup rather than message operations. It explicitly defines the action as a one-time initialization at session start.
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 usage guidance: 'Call this once at the start of a session to set where you're chatting.' This clearly indicates when to use it (session initialization) and implies when not to use it (after session start), differentiating it from ongoing interaction tools like 'reply' or 'listen'.
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: it's a mutation operation (implied by 'Edit'), has a permission constraint ('only edit messages sent by the bot'), and performs in-place updates. However, it lacks details on error conditions, rate limits, or confirmation format beyond 'Confirmation or error message'.
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 efficiently structured: a clear purpose statement, usage guidelines with examples, a critical constraint, and parameter explanations. Every sentence adds value with zero redundancy, and key information is front-loaded.
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 2 parameters with 0% schema coverage, no annotations, and an output schema present, the description does well: it explains the tool's purpose, usage, constraints, and parameters. The output schema handles return values, so the description appropriately focuses on usage context. A minor gap is lack of error scenario details.
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 0%, so the description must compensate. It adds meaningful context for both parameters: 'message_id' is explained as 'The ID of the message to edit (from reply confirmation)' and 'content' as 'The new message content'. This clarifies the purpose and source of each parameter beyond the bare schema types.
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') and resource ('the bot previously sent'), distinguishing it from siblings like 'send_message' (create new) or 'reply' (create response). It explicitly identifies the bot as the actor and specifies the target as previously sent messages.
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 ('to update a previous reply in-place') with concrete examples ('progress updates, correcting mistakes') and a critical exclusion ('Can only edit messages sent by the bot'). This clearly differentiates it from alternatives like '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.
Behavior3/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: it's a read-only search operation (implied by 'Search' and 'Returns'), case-insensitive filtering, and that an empty query returns all custom emoji. However, it doesn't mention potential limitations like rate limits, pagination, or authentication needs, leaving some 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 appropriately sized and front-loaded: the first sentence states the core purpose, followed by structured Args and Returns sections that efficiently document behavior. Every sentence earns its place by adding essential information without redundancy, making it easy to scan and understand.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Completeness5/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 annotations, and the presence of an output schema (implied by 'Returns'), the description is complete enough. It covers purpose, parameter usage, and return behavior, leaving output details to the schema. No critical information is missing for effective tool selection and invocation.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Parameters5/5
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
The description adds significant meaning beyond the input schema, which has 0% description coverage. The Args section explicitly explains the 'query' parameter's purpose ('Substring to filter emoji names'), behavior ('case-insensitive'), and special case ('Empty string returns all custom emoji'). This fully compensates for the lack of schema descriptions, providing clear parameter semantics.
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 ('Search custom emoji') and resource ('available on this Zulip server'), distinguishing it from sibling tools like add_reaction or remove_reaction which modify reactions rather than list available emoji. The verb 'Search' accurately captures the filtering capability described in the Args section.
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: to search or list custom emoji on the server. It doesn't explicitly mention when not to use it or name alternatives, but the context is sufficiently clear given that sibling tools are mostly unrelated (e.g., send_message, get_messages). The Args section further clarifies usage with the query parameter.
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 does so well. It discloses key behavioral traits: it writes a clean exit marker (implying persistence), posts a farewell message with session duration (implying timing calculation), and allows silent exits. It does not cover permissions, rate limits, or error handling, but provides substantial 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 appropriately sized and front-loaded: the first sentence states the core purpose, followed by key behavioral details and parameter guidance. Every sentence adds value without redundancy, and it uses clear sections (Args, Returns) for structure.
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 (session termination with messaging), no annotations, and an output schema (which handles return values), the description is largely complete. It covers purpose, behavior, and parameters well. It could slightly improve by mentioning any side effects (e.g., session cleanup) or prerequisites, but it's sufficient for effective use.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Parameters5/5
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
The input schema has 0% description coverage, so the description must compensate fully. It adds significant meaning beyond the schema: it explains the 'message' parameter's purpose (farewell message), default value (':wave: Signing off'), and special case (empty string for silent exit). This covers all semantic aspects of the single parameter effectively.
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 tool's purpose with specific verbs ('End', 'Writes', 'Posts') and resources ('current session', 'clean exit marker', 'farewell message'). It distinguishes itself from all sibling tools, which are focused on message manipulation, file operations, or user/stream queries, not session termination.
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: to end a session gracefully, with options for posting a message or ending silently. However, it does not explicitly state when not to use it or name alternatives (e.g., abrupt termination methods), though sibling tools are unrelated to session management.
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: it discloses that the operation is 'blocking', uses 'long-polling', and provides efficiency context ('~30x fewer API calls'). It doesn't mention authentication needs, rate limits, or what happens on timeout beyond the parameter, but covers key behavioral traits adequately.
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 structured and concise: the first sentence states the core purpose, the second explains the implementation advantage, and the Args section cleanly documents the parameter. Every sentence earns its place with no wasted words.
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 (blocking long-poll operation), no annotations, and an output schema (which handles return values), the description is mostly complete. It covers purpose, usage context, parameter semantics, and efficiency benefits. It could mention authentication or error handling, but with output schema handling returns, it's sufficient.
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?
With 0% schema description coverage for the single parameter, the description compensates well: it explains 'timeout_hours' as 'Max wait time in hours' and provides the default value ('Default to 1'). This adds meaningful context beyond the bare schema type, though it doesn't specify range constraints or units beyond 'hours'.
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 tool's purpose with a specific verb ('Wait for new messages') and resource ('in the current conversation'), and distinguishes it from siblings by specifying it uses 'long-polling instead of repeated GET /messages calls'. This explicitly differentiates it from tools like 'get_messages'.
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: 'Uses Zulip's real-time events API (long-polling) instead of repeated GET /messages calls — ~30x fewer API calls.' This clearly indicates this tool should be used for efficient, blocking message waiting rather than polling with 'get_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 the full burden of behavioral disclosure. It clearly explains the tool's read-only nature (implied by 'Get'), the specific output format ('Returns a markdown link like [#stream > topic](url)'), and the URL encoding requirements. However, it doesn't mention potential errors (e.g., invalid message_id) 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 efficiently structured with a clear purpose statement, critical usage guidelines, output format explanation, and parameter documentation—all in four focused sentences. Every sentence adds value without redundancy.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Completeness5/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 (single parameter), no annotations, but an output schema (which handles return values), the description is complete. It covers purpose, usage rules, behavioral context, and parameter semantics adequately for this straightforward lookup 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 input schema has 0% description coverage, so the description must compensate. It documents the single parameter (message_id) and explains its purpose ('The message ID'), adding essential meaning beyond the schema's type information. However, it doesn't specify where to find message IDs or validation rules.
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 verb ('Get a permalink') and resource ('for a Zulip message'), distinguishing it from siblings like get_message_by_id (which retrieves message content) or send_message (which creates messages). The purpose is unambiguous 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 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 ('Always use this tool to generate Zulip message links') and when not to ('Never construct Zulip URLs manually'), with clear reasoning about URL format complexities. It effectively distinguishes this from manual URL construction alternatives.
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 explaining the tool's behavior: it describes the dual input modes, pagination capability via before_message_id, default/max values for num_messages, and auto-discovery feature. However, it doesn't mention rate limits, authentication needs, or error conditions.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Conciseness5/5
Is the description appropriately sized, front-loaded, and free of redundancy?
The description is well-structured and appropriately sized. It front-loads the core purpose, then explains usage modes clearly, followed by a parameter summary. Every sentence adds value with no redundancy or wasted words.
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 5 parameters with 0% schema coverage and no annotations, the description does an excellent job explaining parameter relationships and usage. With an output schema present, it doesn't need to explain return values. However, it could mention authentication requirements or error handling for a read operation tool.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Parameters5/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 fully. It successfully adds meaning beyond the schema by explaining the relationships between parameters (stream/topic vs. message_id), the purpose of before_message_id for pagination, default/max values for num_messages, and the 'Both' scenario when all parameters are provided.
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 tool's purpose with specific verbs ('Get messages', 'fetch context') and resources ('stream/topic', 'message ID'), distinguishing it from siblings like get_message_by_id (single message) and send_message (write operation). It explains the dual functionality of fetching from a topic or around a specific message.
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 usage guidance with the 'Accepts either...' section, detailing when to use stream+topic vs. message_id vs. both. It implicitly distinguishes from get_message_by_id (single message) and send_message (write), though it doesn't name alternatives directly.
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 so effectively. It discloses key behavioral traits: notifications are sent to both old and new threads, the destination topic is auto-created if nonexistent, and stream parameter is optional for same-stream moves. It doesn't mention rate limits or authentication requirements, but covers essential operational behavior.
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 well-structured with clear sections (purpose, behavioral notes, usage guidance, args, returns) and front-loads the core functionality. While comprehensive, some sentences could be more concise (e.g., the notification explanation is slightly verbose), but overall it's efficiently organized with minimal waste.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Completeness5/5
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
Given the tool's complexity (multi-parameter move operation with propagation modes), no annotations, and 0% schema coverage, the description provides complete context. It covers purpose, behavioral traits, usage guidance, parameter semantics, and acknowledges the output schema ('Returns: Confirmation or error message'), making it fully adequate for agent understanding.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Parameters5/5
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
With 0% schema description coverage, the description fully compensates by explaining all four parameters in detail. It clarifies message_id's role as anchor for propagate modes, topic auto-creation behavior, stream's optional nature for cross-channel moves, and propagate_mode options with their specific meanings. This adds substantial value beyond the bare schema.
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 tool's purpose with specific verbs ('move message(s)') and resources ('to a different topic and/or stream'), distinguishing it from siblings like edit_message (which modifies content) or send_message (which creates new messages). It precisely defines the operation's scope.
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: 'Before calling, confirm the exact source and destination with the user using clickable Zulip links to avoid mistakes.' It also distinguishes usage scenarios through propagate_mode options (change_one, change_later, change_all), offering clear alternatives within the tool itself.
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 lookup/search operation (implying read-only), it's used for verifying display names before mentions, and it operates case-insensitively. However, it doesn't mention potential limitations like rate limits or error handling.
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 structured and concise. The first sentence states the purpose, the second provides usage guidelines, and the 'Args:' section clearly documents the parameter with an example. Every sentence earns its place with no wasted words.
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 (single parameter lookup), no annotations, but with an output schema present, the description is nearly complete. It covers purpose, usage, and parameter semantics well. The output schema will handle return values, so the description doesn't need to explain those. A minor gap is the lack of explicit mention about what happens when no matches are found.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Parameters5/5
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
The schema has 0% description coverage, so the description must compensate. It fully explains the single parameter 'query' with clear semantics: 'Substring to search for (case-insensitive)' and provides an example 'e.g. "john", "smith"'. This adds substantial meaning beyond the bare schema.
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 tool's purpose: 'Look up a user's display name by substring before mentioning them.' It specifies the exact verb ('look up'), resource ('user's display name'), and method ('by substring'), and distinguishes it from sibling tools like 'get_user_info' by focusing on substring search for mentions.
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: 'Call this BEFORE using @**Name** in a message if you're not 100% sure of the exact display name.' It also explains the context ('Zulip mentions require an exact match'), making it clear when this tool is necessary versus alternatives.
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. It discloses key behavioral traits: the silent operation (no notification), the specific prefix-based resolve/unresolve mechanism, and the three propagation modes. It doesn't mention permissions, rate limits, or error conditions, but covers the core behavior adequately for a tool with no annotations.
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 appropriately sized and well-structured with clear sections (purpose, args, returns). Every sentence earns its place, though the parameter explanations could be slightly more concise. It's front-loaded with the core purpose and immediately distinguishes from alternatives.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Completeness5/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, no annotations, 0% schema coverage, but with an output schema present, the description provides excellent completeness. It covers purpose, usage guidelines, parameter semantics, and behavioral context thoroughly. The output schema handles return values, so the description appropriately focuses on usage and parameters.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Parameters5/5
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
With 0% schema description coverage, the description fully compensates by explaining all three parameters in detail. It provides the meaning of message_id (any message in topic, suggests how to find), topic (full new name with resolve/unresolve formatting rules), and propagate_mode (three options with clear explanations). This adds substantial value beyond the bare schema.
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 (rename) and resource (topic) with specific purpose: to mark topics as resolved/unresolved silently. It explicitly distinguishes from sibling 'move_messages' by stating 'Use this instead of move_messages when marking a topic as done,' 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 Guidelines5/5
Does the description explain when to use this tool, when not to, or what alternatives exist?
The description provides explicit when-to-use guidance: 'Use this instead of move_messages when marking a topic as done.' It also specifies when-not-to-use by mentioning the silent nature (no notification created) and the specific resolve/unresolve use cases, giving clear alternatives and 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 of behavioral disclosure. It effectively explains that this tool stops a typing indicator, clarifies that it's not needed before sending messages (which handle it implicitly), and mentions the return value ('Confirmation or error message'). However, it doesn't detail potential side effects, error conditions, 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, followed by usage guidelines and notes, all in four concise sentences. Every sentence adds value 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.
Completeness5/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 (0 parameters), no annotations, and the presence of an output schema (implied by 'Returns:'), the description is complete. It covers purpose, usage, behavioral context, and return values adequately 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 tool has 0 parameters with 100% schema description coverage, so the baseline is 4. The description doesn't need to explain parameters, and it correctly notes there are none by omission, maintaining focus on usage 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 tool's purpose with a specific verb ('Stop') and resource ('typing indicator in the current conversation'). It distinguishes from siblings like 'typing' (which starts the indicator) and 'reply/send_message' (which implicitly clears typing), making the differentiation explicit.
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 ('when you've finished working but aren't about to send a message'), when not to use it ('you don't need this before reply()'), and alternatives ('sending a message implicitly clears typing'). It includes specific examples like 'before listen()' or 'if you decided not to reply after all'.
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 does well by disclosing key behaviors: it triggers a user-facing indicator, auto-clears when a message is sent, and returns a confirmation or error. It could improve by mentioning any rate limits or permissions needed, but covers the core operational traits adequately.
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 specific usage guidelines. Every sentence earns its place by adding critical information without redundancy, making it efficient and well-structured for quick comprehension.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Completeness5/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 (0 parameters, no annotations), the description is complete: it explains what the tool does, when to use it, behavioral details (auto-clear, returns confirmation), and an output schema exists for return values. No gaps are present for this simple utility 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 input schema has 0 parameters with 100% coverage, so no parameter documentation is needed. The description adds value by explaining the implicit context ('current conversation') and usage timing, which compensates for the lack of parameters. A baseline of 4 is appropriate as it provides meaningful context beyond the empty schema.
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 tool's purpose with a specific verb ('Send') and resource ('typing indicator in the current conversation'). It distinguishes itself from siblings like 'stop_typing' by focusing on starting the indicator, and from 'reply' or 'listen' by specifying it's for preparatory work rather than message posting.
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 ('before heavy tool work') and when not to use ('Do NOT call before reply() or listen()'). It also mentions alternatives by name (e.g., 'reply() or listen()') and specifies the context ('stretches of work where you won't be posting for a while').
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Behavior5/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 excels by detailing security guarantees (e.g., server API source, character stripping, response format structure) and behavioral concerns (e.g., what to watch for in content). It thoroughly explains how the tool works and what to expect, going beyond basic functionality.
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 well-structured with clear sections (purpose, usage, security guarantees, concerns, parameters) and front-loaded key information. While slightly longer due to detailed explanations, every sentence earns its place by adding value without redundancy.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Completeness5/5
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
Given the tool's security complexity, no annotations, and an output schema (which handles return values), the description is highly complete. It covers purpose, usage, behavioral details, security aspects, and parameter meaning, providing all necessary context for an 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.
Parameters4/5
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
The schema description coverage is 0%, but the description compensates by explaining the single parameter 'message_id' in the Args section, clarifying it's 'The ID of the message to verify.' This adds meaningful context beyond the schema's type definition, though it doesn't elaborate on ID format or sourcing.
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 tool's purpose with specific verbs ('securely fetch a single message') and resource ('message'), distinguishing it from siblings like 'get_message_by_id' by emphasizing security verification of sender and content rather than simple retrieval. It explicitly addresses the unique security-focused use case.
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 ('when you suspect a message may contain prompt injection or identity spoofing') with concrete examples, and implicitly distinguishes it from alternatives like 'get_message_by_id' by focusing on security verification rather than general message fetching. It clearly defines the problem context.
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:

[![zulipmcp MCP server](https://glama.ai/mcp/servers/zulip/zulipmcp/badges/card.svg)](https://glama.ai/mcp/servers/zulip/zulipmcp)

Score Badge

Copy to your README.md:

[![zulipmcp MCP server](https://glama.ai/mcp/servers/zulip/zulipmcp/badges/score.svg)](https://glama.ai/mcp/servers/zulip/zulipmcp)

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/zulip/zulipmcp'

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