lark-hermes-mcp

Server Quality Checklist

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

Latest release: v0.1.0
Disambiguation2/5
There is significant overlap and confusion between tools, especially in the IM and document domains. For example, sendMessageFeishu and feishu_im_user_message both send messages, while feishu_fetch_doc and docxGetRawContent both retrieve document content. The descriptions help somewhat, but the boundaries are unclear, leading to potential misselection.
Naming Consistency2/5
Naming is highly inconsistent with mixed conventions. Some tools use snake_case (feishu_bitable_app), others use camelCase (bitableCreateRecord), and some are a mix (sendMessageFeishu). Verb styles vary (create vs. list vs. get), and there's no predictable pattern across the set.
Tool Count2/5
With 53 tools, this is far too many for a coherent MCP server. The scope covers multiple domains (Bitable, Calendar, Docs, IM, Tasks, etc.), but the tool count feels bloated and heavy, making it difficult for agents to navigate effectively.
Completeness4/5
The server covers a wide range of Feishu/Lark functionalities with extensive CRUD operations across domains like Bitable, Calendar, Docs, and IM. While there are some minor gaps (e.g., no tool for deleting calendar events in the calendarCreateEvent set), the overall surface is quite comprehensive for the stated purpose.
Average 3.6/5 across 53 of 53 tools scored. Lowest: 2.7/5.
See the Tool Scores section below for per-tool breakdowns.
- 0 of 1 community issues answered or closed in the last 6 months
- 0 commits in the last 12 weeks
- No stable releases found
- No critical vulnerability alerts
- No high-severity vulnerability alerts
- No code scanning findings
- CI status not available
This repository is licensed under MIT License.
This repository includes a README.md file.
No tool usage detected in the last 30 days. Usage tracking helps demonstrate server value.
Tip: use the "Try in Browser" feature on the server page to seed initial usage.
Add a glama.json file to provide metadata about your server.
If you are the author, simply .
If the server belongs to an organization, first add glama.json to the root of your repository:
```
{
  "$schema": "https://glama.ai/mcp/schemas/server.json",
  "maintainers": [
    "your-github-username"
  ]
}
```
Then . Browse examples.
Add related servers to improve discoverability.

How to sync the server with GitHub?

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

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

How is the quality score calculated?

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

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

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

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

Tool Scores

Behavior2/5
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
With no annotations provided, the description carries full burden for behavioral disclosure. It mentions pagination ('按页列出') and support for filtering/sorting, but doesn't describe authentication needs, rate limits, error conditions, or what the return format looks like. For a tool with 8 parameters and no output schema, this leaves significant behavioral gaps.
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 a single sentence that front-loads the core purpose. Every element (pagination, resource, supported features) earns its place without redundancy. However, the Chinese-only text might limit accessibility in some contexts.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Completeness2/5
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
For a tool with 8 parameters, no annotations, and no output schema, the description is incomplete. It doesn't explain authentication requirements, response format, error handling, or detailed parameter usage. While it covers the basic purpose, it lacks the depth needed for effective tool selection and invocation given the complexity.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Parameters2/5
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
Schema description coverage is 0%, so the description must compensate. It mentions filter, field_names, and sort parameters, but doesn't explain the other 5 parameters (app_token, table_id, view_id, page_size, page_token) or provide syntax/format details. The brief mention of three parameters doesn't adequately cover the complexity of 8 total parameters.
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: '按页列出某张数据表的记录' (list records of a data table by page). It specifies the resource (data table records) and verb (list by page), and distinguishes it from siblings like bitableCreateRecord and bitableUpdateRecord. However, it doesn't explicitly differentiate from other listing tools like calendarListEvents, which would require a 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. It mentions support for filter, field_names, and sort, but doesn't indicate when to use this versus other listing tools (e.g., calendarListEvents) or other bitable tools. There's no mention of prerequisites, exclusions, or specific contexts for application.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Behavior2/5
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
No annotations are provided, so the description carries the full burden. It states this is an update operation ('更新'), implying mutation, but doesn't disclose behavioral traits such as required permissions, whether changes are reversible, error handling, or rate limits. The mention of '部分更新' (partial update) adds some context about scope, but overall, critical behavioral details are missing 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.
Conciseness4/5
Is the description appropriately sized, front-loaded, and free of redundancy?
The description is concise with two sentences, front-loaded with the core action. It avoids unnecessary words, but could be slightly more structured (e.g., separating key points). Every sentence contributes value, making it efficient though not perfectly optimized.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Completeness2/5
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
Given the complexity of a mutation tool with 4 parameters, 0% schema coverage, no annotations, and no output schema, the description is incomplete. It lacks details on behavioral traits, parameter meanings, return values, and usage context. This is inadequate for safe and effective tool invocation by an AI agent.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Parameters2/5
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
Schema description coverage is 0%, so the schema provides no parameter details. The description adds minimal semantics: it mentions 'fields' as a JSON string for modifying fields, but doesn't explain the purpose or format of app_token, table_id, or record_id. This partially compensates for one parameter but leaves three undocumented, failing to fully address the coverage gap.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Purpose4/5
Does the description clearly state what the tool does and how it differs from similar tools?
The description clearly states the verb ('更新' meaning 'update') and resource ('record_id 的字段' meaning 'fields of record_id'), specifying it's a partial update. It distinguishes from bitableCreateRecord (create vs update) but doesn't explicitly differentiate from other update tools in the sibling list. The purpose is specific but could better highlight its unique scope among siblings.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Usage Guidelines2/5
Does the description explain when to use this tool, when not to, or what alternatives exist?
No explicit guidance on when to use this tool versus alternatives is provided. The description mentions '部分更新' (partial update), which implies usage for modifying specific fields, but it doesn't state when to choose this over bitableCreateRecord or other update-related tools, nor does it mention prerequisites or exclusions. Usage is implied but not clearly defined.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Behavior2/5
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
No annotations are provided, so the description carries full burden. It states it lists calendars visible to the current identity, implying a read-only operation, but doesn't disclose behavioral traits like pagination behavior (despite page_size/page_token parameters), rate limits, authentication needs, or what 'visible' means in practice. The description is minimal and lacks crucial 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.
Conciseness4/5
Is the description appropriately sized, front-loaded, and free of redundancy?
The description is a single, efficient sentence in Chinese with no wasted words. It's front-loaded with the core action and resource. However, it could be more structured by explicitly separating purpose from scope details.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Completeness2/5
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
Given 2 parameters with 0% schema coverage, no annotations, no output schema, and moderate complexity (listing resources with pagination), the description is incomplete. It lacks parameter explanations, behavioral details, output format, and sufficient context for reliable tool invocation. It's minimally viable but with significant gaps.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Parameters2/5
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
Schema description coverage is 0%, so the description must compensate. It adds no information about the 2 parameters (page_size, page_token), leaving their purpose, format, and usage completely undocumented. The description mentions calendar types but doesn't link them to parameters. Baseline would be 1 if not for the implicit context from the tool name and description scope.
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 ('列出' meaning 'list') and resource ('日历' meaning 'calendars'), specifying it lists calendars visible to the current identity. It distinguishes from siblings like calendarListEvents (lists events, not calendars), but doesn't explicitly differentiate from other calendar-related tools like feishu_calendar_calendar. Purpose is clear but sibling differentiation is implicit.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Usage Guidelines2/5
Does the description explain when to use this tool, when not to, or what alternatives exist?
No explicit guidance on when to use this tool versus alternatives. The description mentions calendar types (primary/exchange/google/resource), which hints at scope, but doesn't provide when-not-to-use scenarios or name specific alternatives. Usage is implied rather than clearly defined.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Behavior2/5
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
With no annotations provided, the description carries full burden for behavioral disclosure. It mentions the time format (10-digit Unix seconds) but doesn't describe pagination behavior (despite page_size and page_token parameters), rate limits, authentication requirements, error conditions, or what the output looks like. '列出' (list) implies read-only, but this isn't explicitly stated. The description adds minimal behavioral context 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 appropriately concise with two sentences. The first sentence states the core functionality, and the second provides specific format guidance for two parameters. There's no wasted text, though it could be more front-loaded with critical information. The structure is efficient for its limited content.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Completeness2/5
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
Given 5 parameters with 0% schema coverage, no annotations, and no output schema, the description is incomplete. It explains time format but misses pagination behavior, authentication, error handling, and output structure. For a list operation with multiple parameters and no structured documentation, this leaves significant gaps for an AI agent to understand proper usage.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Parameters2/5
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
Schema description coverage is 0%, so the description must compensate. It only explains start_time and end_time parameters (format: 10-digit Unix seconds), leaving calendar_id, page_size, and page_token completely undocumented. With 5 parameters total and only 2 partially explained, the description fails to provide adequate parameter semantics beyond what's minimally implied by the tool name.
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 ('列出' - list) and resource ('日程' - events/calendar events) with specific scope ('指定日历在时间区间内' - specified calendar within time range). It distinguishes from siblings like calendarCreateEvent (create) and calendarListCalendars (list calendars), but doesn't explicitly differentiate from other listing tools. The purpose is specific but could be more distinctive.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Usage Guidelines2/5
Does the description explain when to use this tool, when not to, or what alternatives exist?
The description provides no guidance on when to use this tool versus alternatives. It doesn't mention prerequisites (e.g., authentication), when to choose this over other event-related tools, or any constraints beyond the time range parameters. There's no comparison to siblings like feishu_calendar_event or feishu_calendar_freebusy.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Behavior2/5
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
No annotations are provided, so the description carries full burden. It mentions preserving style/hierarchy, which adds some behavioral context. However, it doesn't disclose critical traits like pagination behavior (implied by page_size/page_token but not explained), rate limits, authentication needs, or whether it's read-only (implied but not stated). The description is insufficient for a tool with pagination parameters.
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 a single, efficient sentence in Chinese that front-loads the core purpose. It avoids unnecessary words, though it could be slightly clearer. Every part contributes to understanding the tool's function.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Completeness2/5
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
Given the tool's complexity (pagination, no annotations, no output schema), the description is incomplete. It lacks details on return format, error handling, authentication, and doesn't fully explain parameters. For a tool that likely returns structured block data, this leaves significant gaps for an AI agent.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Parameters2/5
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
Schema description coverage is 0%, so the description must compensate. It mentions '文档根 block 或指定 block' (document root block or specified block), which hints at document_id usage but doesn't clarify if block_id is a parameter (it's not in schema). It doesn't explain page_size/page_token at all, leaving three parameters undocumented. The description adds minimal value beyond the schema.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Purpose4/5
Does the description clearly state what the tool does and how it differs from similar tools?
The description clearly states the action ('列出' meaning 'list') and resource ('文档根 block 或指定 block 的子结构'), specifying it retrieves document blocks with style/hierarchy preserved. It distinguishes from siblings like docxGetRawContent (which gets raw content) and feishu_fetch_doc (which likely fetches entire documents). However, it doesn't explicitly differentiate from other listing tools in the context.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Usage Guidelines2/5
Does the description explain when to use this tool, when not to, or what alternatives exist?
The description provides no guidance on when to use this tool versus alternatives. It doesn't mention prerequisites (e.g., needing document access), exclusions, or compare to siblings like feishu_search_doc_wiki for searching. Usage is implied by the action but lacks explicit context.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Behavior2/5
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
With no annotations provided, the description carries full burden for behavioral disclosure. While it states this is a creation operation, it doesn't mention required permissions, whether the operation is idempotent, error conditions, or what happens on success/failure. The description adds some context about time format requirements but lacks comprehensive behavioral information 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.
Conciseness4/5
Is the description appropriately sized, front-loaded, and free of redundancy?
The description is appropriately concise with two sentences that each add value. The first sentence states the core purpose, and the second provides critical format details for time parameters. There's no wasted language, though the structure could be slightly improved with clearer separation between purpose and parameter guidance.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Completeness2/5
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
For a 7-parameter mutation tool with no annotations and no output schema, the description is insufficient. It doesn't explain what happens after creation, error handling, required permissions, or the relationship between parameters. The time format guidance is helpful but doesn't compensate for the significant gaps in behavioral and contextual information.
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 only 29%, but the description adds meaningful context for start_time, end_time, and timezone parameters by specifying format requirements (10-digit unix seconds string) and providing a timezone example. However, it doesn't address the other 4 parameters (calendar_id, summary, description, need_notification) beyond what the minimal schema provides.
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 ('创建日程' - create event) and resource ('在指定日历下' - under specified calendar), providing a specific verb+resource combination. However, it doesn't explicitly differentiate from sibling tools like 'calendarListEvents' or 'feishu_calendar_event', which would require a 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. There are multiple calendar-related sibling tools (calendarListCalendars, calendarListEvents, feishu_calendar_event, feishu_calendar_freebusy) but no indication of when this create operation is appropriate versus listing or other calendar operations.
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 mentions the output is '纯文本内容(去格式)' (plain text without formatting), which is useful. However, it doesn't address critical behavioral aspects: whether this is a read-only operation, what authentication is required, rate limits, error conditions, or what happens with large documents. For a tool that fetches document content, this leaves significant gaps.
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 in a single Chinese sentence that states the purpose upfront. The parenthetical '(去格式)' and usage note '用于阅读/总结' add value without unnecessary elaboration. While concise, it could potentially benefit from slightly more detail given the complete lack of parameter documentation.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Completeness2/5
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
For a tool with 2 parameters (one required), 0% schema coverage, no annotations, and no output schema, the description is insufficient. It explains what the tool does at a high level but fails to provide necessary context about parameters, authentication requirements, error handling, or output format details. The agent would struggle to use this tool correctly without additional information.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Parameters2/5
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
With 0% schema description coverage for 2 parameters, the description provides no information about the 'document_id' or 'lang' parameters. It doesn't explain what format the document_id should be in, where to obtain it, what the lang parameter controls, or what values it accepts. The description fails to compensate for the complete lack of parameter documentation in the schema.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Purpose4/5
Does the description clearly state what the tool does and how it differs from similar tools?
The description clearly states the action ('获取' meaning 'get'), the resource ('新版云文档的纯文本内容'), and the transformation ('去格式' meaning 'remove formatting'). It distinguishes from potential siblings by specifying '纯文本内容(去格式)' rather than formatted content. However, it doesn't explicitly differentiate from tools like 'feishu_fetch_doc' or 'docxListBlocks' that might handle similar documents.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Usage Guidelines3/5
Does the description explain when to use this tool, when not to, or what alternatives exist?
The description provides implied usage context with '用于阅读/总结' (for reading/summarizing), suggesting this tool is appropriate for content extraction tasks. However, it lacks explicit guidance on when to use this tool versus alternatives like 'feishu_fetch_doc' or 'docxListBlocks', and doesn't mention any prerequisites or exclusions.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Behavior2/5
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
With no annotations provided, the description carries full burden for behavioral disclosure. While it mentions '以用户身份' (as user identity), it doesn't specify authentication requirements, rate limits, error conditions, or what the tool returns. For a multi-action tool with no annotation coverage, this leaves significant behavioral gaps.
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 reasonably concise with two sentences that cover the tool's purpose and available actions. It's front-loaded with the main purpose, though the Chinese characters and action listing format could be slightly more structured for clarity.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Completeness2/5
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
For a multi-action tool with 4 parameters, no annotations, and no output schema, the description is insufficient. It doesn't explain what each action returns, how pagination works with the list action, or the relationships between actions and parameters. The tool has significant complexity that isn't adequately addressed.
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 mentions the three action types but doesn't explain what each action does with the parameters. With 75% schema description coverage (3 of 4 parameters have descriptions), the baseline is 3. The description adds minimal value beyond what's already in the schema descriptions for page_size, page_token, and calendar_id.
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 this is a '飞书日历管理工具' (Feishu calendar management tool) with specific actions (list, get, primary), which provides a verb+resource combination. However, it doesn't distinguish this tool from sibling tools like 'calendarListCalendars' or 'feishu_calendar_event', which handle similar calendar-related operations.
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 lists the three available actions but provides no guidance on when to use each action versus alternatives. There's no mention of when to use 'list' versus 'primary', or how this tool differs from other calendar-related tools in the sibling list like 'calendarListCalendars' or 'feishu_calendar_event'.
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. While it mentions the tool creates documents and supports asynchronous queries, it doesn't describe important behavioral aspects: whether this requires specific permissions, what happens on failure, whether documents are immediately available, rate limits, or what the response contains. The asynchronous functionality is mentioned but not explained in detail.
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 very concise - just one sentence in Chinese. It's front-loaded with the main purpose and includes the asynchronous functionality. However, it could be more structured by separating the creation functionality from the query functionality for clarity.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Completeness2/5
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
For a document creation tool with 6 parameters and no annotations or output schema, the description is insufficient. It doesn't explain the tool's behavior, error conditions, response format, or how the asynchronous functionality works. The mention of task_id query suggests dual functionality (create AND query), but this isn't adequately explained given the complexity.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Parameters3/5
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
Schema description coverage is 100%, so the schema already documents all 6 parameters thoroughly. The description adds minimal value beyond the schema - it mentions Markdown content and asynchronous task_id queries, but doesn't provide additional context about parameter interactions, constraints, or usage patterns that aren't already in the schema descriptions.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Purpose4/5
Does the description clearly state what the tool does and how it differs from similar tools?
The description clearly states the tool's purpose: '从 Markdown 创建云文档' (create cloud document from Markdown). It specifies the verb ('创建' - create) and resource ('云文档' - cloud document), and mentions support for asynchronous task_id queries. However, it doesn't explicitly differentiate from sibling tools like 'feishu_update_doc' or 'feishu_fetch_doc', 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 minimal usage guidance. It mentions asynchronous task_id query support, but doesn't explain when to use this tool versus alternatives like 'feishu_update_doc' or 'feishu_fetch_doc'. No context about prerequisites, when to choose this over other document creation methods, or any exclusions are provided.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Behavior2/5
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
With no annotations provided, the description carries full burden for behavioral disclosure. It mentions the return format ('返回匹配的员工列表，包含姓名、部门、open_id 等信息') which is helpful, but doesn't cover important behavioral aspects like authentication requirements, rate limits, error conditions, or whether this is a read-only operation. For a search tool with zero annotation coverage, this leaves significant gaps in understanding how the tool behaves.
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 clear sentences. The first sentence explains the search functionality and scope, the second describes the return format. No wasted words, though it could be slightly more front-loaded with the core purpose.
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 (search with pagination), no annotations, and no output schema, the description provides basic functional context but lacks important details. It explains what the tool does and what it returns, but doesn't cover behavioral aspects like pagination mechanics (beyond what's in the schema), authentication needs, or error handling. For a search tool without annotations or output schema, this is minimally adequate.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Parameters3/5
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
Schema description coverage is 100%, so the schema already fully documents all three parameters. The description adds minimal value beyond the schema - it mentions keyword searching for name, phone, and email, which aligns with the 'query' parameter but doesn't provide additional syntax or format details. Baseline 3 is appropriate when the schema does the heavy lifting.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
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: '搜索员工信息（通过关键词搜索姓名、手机号、邮箱）' specifies the action (search) and resource (employee information) with search scope details. It distinguishes from sibling tools like 'feishu_get_user' which appears to fetch a specific user rather than search. However, it doesn't explicitly contrast with 'feishu_im_user_search_messages' which searches messages rather than users.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Usage Guidelines2/5
Does the description explain when to use this tool, when not to, or what alternatives exist?
No explicit guidance on when to use this tool versus alternatives. The description doesn't mention when this search is appropriate versus using 'feishu_get_user' for specific user lookup or other search tools. It provides basic functional context but no decision-making criteria for the agent.
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 lists actions but doesn't describe their effects (e.g., whether 'create' is idempotent, what 'patch' updates, or how 'list' handles pagination). It misses critical details like error conditions, rate limits, or authentication requirements, leaving the agent with insufficient behavioral context.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Conciseness4/5
Is the description appropriately sized, front-loaded, and free of redundancy?
The description is concise and well-structured: one sentence states the purpose, followed by a bullet-like list of actions. There's no wasted text, and information is front-loaded. However, the use of brackets and informal formatting slightly reduces clarity, preventing a perfect score.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Completeness2/5
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
Given the tool's complexity (13 parameters, multiple actions) and lack of annotations and output schema, the description is incomplete. It doesn't explain return values, error handling, or how actions map to parameters. For a multi-action tool with high parameter count, this leaves significant gaps for an agent to operate effectively.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Parameters3/5
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
Schema description coverage is 77%, which is high, so the baseline is 3. The description adds minimal value beyond the schema: it implies the tool handles custom groups and lists actions, but doesn't explain parameter interactions (e.g., how 'action' dictates which other parameters are relevant) or provide examples. It compensates slightly by clarifying the tool's scope, but doesn't fully address the 23% coverage gap.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Purpose4/5
Does the description clearly state what the tool does and how it differs from similar tools?
The description clearly states the tool's purpose: '飞书任务自定义分组管理工具。用于创建、查询、更新自定义分组，以及列出分组内的任务。' It specifies the verb (manage custom groups) and resource (Feishu task custom groups), and lists the five specific actions. However, it doesn't explicitly differentiate from sibling tools like feishu_task_task or feishu_task_tasklist, which handle tasks and task lists respectively.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Usage Guidelines2/5
Does the description explain when to use this tool, when not to, or what alternatives exist?
The description provides no guidance on when to use this tool versus alternatives. It doesn't mention prerequisites (e.g., authentication), compare with sibling tools (e.g., feishu_task_task for individual tasks), or specify contexts where this tool is preferred. The only contextual hint is '以用户身份' (as a user), but this is vague and not operational.
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 mentions the update modes and async task support, but doesn't address critical behavioral aspects: whether this requires specific permissions, what happens on failure, whether changes are reversible, rate limits, or what the response format looks like. For a mutation tool with 7 parameters and 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 efficiently packed into a single Chinese sentence that covers the core functionality and key feature (async support). Every element earns its place, though it could benefit from better structure (separating core function from additional features).
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Completeness2/5
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
For a complex mutation tool with 7 parameters, no annotations, and no output schema, the description is inadequate. It doesn't explain what happens after invocation, error conditions, permission requirements, or how different update modes affect the document. The agent would struggle to use this tool correctly without trial and error.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Parameters3/5
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
Schema description coverage is 100%, so the schema already documents all 7 parameters thoroughly. The description adds minimal value beyond the schema - it mentions the update modes (already in schema) and async task support (already documented in the task_id parameter). Baseline 3 is appropriate when schema does the heavy lifting.
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 ('更新云文档' - update cloud document) and lists the specific update modes available (overwrite/append/replace_range/etc.), which provides good specificity. However, it doesn't explicitly differentiate from sibling tools like 'feishu_create_doc' or 'feishu_fetch_doc' beyond the 'update' verb.
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 mentions support for asynchronous task_id queries, which provides some context about when this might be useful. However, it offers no guidance on when to choose specific update modes, when to use this tool versus alternatives like 'feishu_create_doc', or any prerequisites for using the tool effectively.
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 offers limited behavioral insight. It mentions listing '最近的消息' (recent messages) which implies recency but doesn't specify default time ranges, pagination behavior, rate limits, authentication requirements, or what '最近' means. The description doesn't contradict annotations (none exist), but fails to adequately disclose operational characteristics for a 6-parameter tool.
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 brief and front-loaded with essential information in a single Chinese sentence. While efficient, it could be more structured with clearer separation of purpose from parameter guidance. Every word contributes meaning, but the density might require careful parsing by non-native speakers.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Completeness2/5
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
For a 6-parameter listing tool with no annotations and no output schema, the description is insufficient. It doesn't explain what the tool returns (message format, fields included), how pagination works with page_token, time range defaults, error conditions, or authentication requirements. The agent lacks critical context to use this tool effectively beyond basic invocation.
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 only 33% (2 of 6 parameters have descriptions). The description adds minimal parameter context - it clarifies that container_id is '通常是 chat_id' (usually chat_id) and container_id_type defaults to 'chat', which helps interpret two parameters. However, it doesn't explain the other four parameters (start_time, end_time, page_size, page_token) beyond what the schema provides, leaving significant gaps in understanding.
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 ('消息' - messages) with specific context ('飞书 IM' - Feishu IM, '指定 container' - specified container). It distinguishes from some siblings like 'sendMessageFeishu' but doesn't explicitly differentiate from similar listing tools like 'feishu_im_user_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 Guidelines2/5
Does the description explain when to use this tool, when not to, or what alternatives exist?
The description provides minimal guidance - it mentions container types default to 'chat' but offers no explicit when-to-use advice, no comparison to alternatives like 'feishu_im_user_get_messages' or 'feishu_im_user_search_messages', and no prerequisites or exclusion criteria. The agent must infer usage from the description 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 for behavioral disclosure. It states the tool sends an interactive card, implying a write operation, but doesn't disclose authentication requirements, rate limits, error handling, or what happens upon success/failure. The mention of 'JSON string' format is helpful but insufficient for a mutation 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.
Conciseness4/5
Is the description appropriately sized, front-loaded, and free of redundancy?
The description is a single, efficient sentence that front-loads the core purpose. It wastes no words, though it could benefit from slight structural improvements like separating format requirements from the main action. The Chinese brackets are unnecessary but don't significantly impact readability.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Completeness2/5
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
For a mutation tool with no annotations and no output schema, the description is incomplete. It covers the basic action and card format but lacks crucial context: authentication needs, response format, error conditions, rate limits, and how to interpret 'receive_id_type' enum values. The absence of output schema means the description should ideally hint at return values, which it doesn't.
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 only 33% (1 of 3 parameters has descriptions), so the description must compensate. It adds meaningful context for the 'card' parameter by specifying it must be a 'Feishu interactive card JSON string' with examples of required components ('header/elements or template_id + template_variable'). However, it provides no additional semantics for 'receive_id_type' or 'receive_id', leaving those parameters under-documented.
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 ('send') and resource ('interactive card') with specific platform context ('Feishu IM'). It distinguishes from sibling 'sendMessageFeishu' by specifying card-based messaging, though it doesn't explicitly mention this distinction. The purpose is specific but could be more explicit about sibling differentiation.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Usage Guidelines2/5
Does the description explain when to use this tool, when not to, or what alternatives exist?
No guidance is provided on when to use this tool versus alternatives like 'sendMessageFeishu' or other messaging tools. The description mentions the card must be a JSON string, but this is a technical requirement rather than usage context. There's no mention of prerequisites, error conditions, or typical use cases.
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 the reply_in_thread behavior, which is useful, but doesn't cover other critical aspects like authentication requirements, rate limits, error handling, or what the tool returns (since no output schema exists). For a mutation tool (replying modifies chat state) with zero annotation coverage, this leaves significant gaps in understanding its behavior.
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 two sentences in Chinese, front-loading the core purpose and adding a key parameter detail. Every word earns its place, with no redundant information. It's appropriately sized for the tool's complexity.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Completeness2/5
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
Given the tool's complexity (a mutation tool with 5 parameters, 0% schema coverage, no annotations, and no output schema), the description is incomplete. It lacks details on authentication, error cases, return values, and full parameter semantics. While concise, it doesn't provide enough context for safe and effective use by an AI agent, especially compared to richer sibling tools in the list.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Parameters2/5
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
Schema description coverage is 0%, meaning none of the 5 parameters have descriptions in the schema. The description only explains one parameter (reply_in_thread) and hints at message_id and content (via '回复指定 message_id 的消息'), but doesn't cover msg_type, uuid, or provide details on content format or message_id sourcing. It adds minimal value beyond the bare schema, insufficient to compensate for the low coverage.
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: '回复指定 message_id 的消息' (reply to a specific message with message_id). It specifies the verb (reply) and resource (message), but doesn't explicitly differentiate from sibling tools like 'sendMessageFeishu' or 'listMessagesFeishu' beyond the 'reply' action. The mention of Feishu IM provides some context, but sibling differentiation is implicit rather than explicit.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Usage Guidelines3/5
Does the description explain when to use this tool, when not to, or what alternatives exist?
The description provides some usage context with 'reply_in_thread=true 时在话题里回复' (when reply_in_thread=true, reply in a thread), which implies when to use this parameter. However, it doesn't explicitly state when to use this tool versus alternatives like 'sendMessageFeishu' (which might be for new messages) or 'listMessagesFeishu' (for reading). The guidance is implied but not comprehensive.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Behavior2/5
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
No annotations are provided, so the description carries full burden. It states this is a creation operation but doesn't disclose behavioral traits like authentication requirements, rate limits, error conditions, or what happens on success. The description mentions the fields parameter format but doesn't explain the creation process or response behavior.
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 - just two sentences that directly state what the tool does and provide essential parameter guidance. Every word serves a purpose with zero waste or redundancy.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Completeness2/5
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
For a mutation tool (create operation) with no annotations and no output schema, the description is insufficient. It doesn't explain what happens after creation, error handling, authentication needs, or the scope of the operation. The context signals show this is a 3-parameter tool with low schema coverage, requiring more comprehensive guidance.
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 only 33% schema description coverage (only the 'fields' parameter has a description), the description compensates by explaining that 'fields' should be a 'JSON string: {"字段A":"val","字段B":123}', which adds crucial semantic context beyond the basic type declaration. This significantly helps understand how to format the fields parameter.
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 ('创建一条记录' - create a record) and resource ('在指定数据表中' - in a specified data table), making the purpose understandable. It doesn't explicitly differentiate from sibling tools like bitableUpdateRecord, but the verb 'create' inherently distinguishes it from update operations.
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. While the description implies it's for creating records in a specific table, it doesn't mention prerequisites, when not to use it, or how it relates to sibling tools like bitableListRecords or bitableUpdateRecord.
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 offers minimal behavioral disclosure. It lists actions but doesn't describe what 'delete' entails (permanent? reversible?), what 'copy' includes (structure only or with data?), authentication requirements, rate limits, or error conditions. The description mentions '以用户身份' (as user identity) which hints at authorization context but lacks specifics.
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 reasonably concise with two sentences: one stating purpose/context, one listing actions. The action list is comprehensive but could be more structured. No wasted words, though some information density could be improved by integrating action descriptions with parameter guidance.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Completeness2/5
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
For a 7-parameter tool with no annotations and no output schema, the description is insufficient. It doesn't explain return values, error handling, or how different actions affect parameter requirements. The high schema coverage helps, but the description should provide more operational context given the tool's complexity and mutation capabilities (create, patch, delete, copy).
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 high (86%), so the baseline is 3. The description adds no parameter-specific information beyond what's in the schema - it doesn't explain how 'action' values map to different parameter requirements, or provide examples of 'name' or 'folder_token' usage. The schema already documents parameters well, so the description doesn't add meaningful semantic value.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Purpose4/5
Does the description clearly state what the tool does and how it differs from similar tools?
The description clearly states the tool's purpose: '飞书多维表格应用管理工具' (Feishu multi-dimensional table application management tool) with specific actions listed (create, get, list, patch, delete, copy). It distinguishes from siblings like bitableCreateRecord or feishu_bitable_app_table by focusing on app-level management rather than table/record operations. However, it doesn't explicitly contrast with all similar siblings.
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 basic usage context: '当用户要求创建/查询/管理多维表格时使用' (use when user requests creating/querying/managing multi-dimensional tables). It implies this is for app-level operations but doesn't explicitly state when to use this vs. sibling tools like feishu_bitable_app_table or bitableCreateRecord, nor does it mention prerequisites or exclusions.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
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 mentions the two actions (create and list) but provides minimal behavioral context. No information about permissions required, rate limits, error conditions, whether operations are idempotent, or what the response looks like. For a tool with 9 parameters and no output schema, this is a significant gap in behavioral transparency.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Conciseness4/5
Is the description appropriately sized, front-loaded, and free of redundancy?
The description is appropriately concise - three sentences that efficiently convey the tool's domain, usage context, and available actions. It's front-loaded with the core purpose. No wasted words, though it could be slightly more structured by separating usage guidance from action enumeration.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Completeness2/5
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
For a tool with 9 parameters, no annotations, and no output schema, the description is insufficiently complete. It doesn't explain what the tool returns, error conditions, authentication requirements, or how the different parameters interact (e.g., which parameters are needed for create vs list actions). The description provides basic orientation but leaves critical operational details unspecified.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Parameters3/5
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
Schema description coverage is 67%, providing decent parameter documentation. The description doesn't add any parameter-specific information beyond what's in the schema - it mentions 'create' and 'list' actions which correspond to the 'action' parameter enum, but provides no additional semantic context about when to use which parameters or how they interact. The baseline of 3 is appropriate given the moderate schema coverage.
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: '飞书日程参会人管理工具' (Feishu calendar event attendee management tool) and specifies actions 'create（添加参会人）, list（查询参会人列表）'. It distinguishes from some siblings like calendar event tools, but doesn't explicitly differentiate from other attendee-related tools that might exist. The verb+resource combination is specific and actionable.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Usage Guidelines3/5
Does the description explain when to use this tool, when not to, or what alternatives exist?
The description provides some usage context: '当用户要求邀请/添加参会人、查看参会人列表时使用' (use when users request to invite/add attendees or view attendee lists). This gives implied guidance on when to use it, but doesn't explicitly state when NOT to use it or mention alternatives among the many sibling tools. No prerequisites or constraints 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 full burden for behavioral disclosure. It mentions the tool operates '以用户身份' (as a user), implying authentication requirements, but doesn't specify permissions needed, rate limits, pagination behavior beyond the schema's page_size/page_token, or what happens on errors. For a multi-action tool with no annotation coverage, this leaves significant behavioral gaps.
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 overall purpose and another listing actions with brief explanations. It's front-loaded with the tool's scope. However, the second sentence is somewhat dense, combining both actions without clear separation, which slightly affects readability.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Completeness2/5
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
Given the tool's complexity (6 parameters, 2 actions, no output schema, no annotations), the description is incomplete. It doesn't explain return values, error conditions, authentication needs, or how actions map to parameters (e.g., that chat_id is required for get but not search). For a multi-function tool with significant behavioral aspects, this leaves too much unspecified.
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 high (83%), so the baseline is 3. The description adds minimal value beyond the schema: it mentions that search supports '关键词匹配群名称、群成员' (keyword matching group names and members) and get retrieves '详细信息' (detailed information), but these are already implied by parameter names and schema descriptions. No additional syntax, format, or constraint details are provided.
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: '以用户身份调用飞书群聊管理工具' (Invoke Feishu group chat management tools as a user) and lists two specific actions (search and get). It distinguishes this tool from siblings like feishu_chat_members by focusing on group-level operations rather than member management. However, it doesn't explicitly differentiate from other chat-related tools in the sibling list.
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 by specifying two actions and their purposes (search for finding groups, get for detailed information). However, it doesn't provide explicit guidance on when to choose this tool versus alternatives like feishu_search_user or feishu_chat_members, nor does it mention prerequisites or exclusions. The guidance is functional but lacks comparative context.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Behavior2/5
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
With no annotations provided, the description carries full burden for behavioral disclosure. It mentions the tool operates '以用户身份' (as user identity), which hints at authentication context, but doesn't specify required permissions, rate limits, error behaviors, or whether operations are idempotent. For a tool with both create and list actions (potentially involving mutations), this leaves significant behavioral gaps.
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 reasonably concise with two sentences that cover purpose and usage. The structure is front-loaded with the core purpose. However, the inclusion of 'Actions: create, list' feels redundant since these are already defined in the schema's enum, and the description could be more efficiently worded.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Completeness2/5
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
Given the tool's complexity (9 parameters with nested objects, no output schema, no annotations), the description is insufficient. It doesn't explain return formats for list actions, error conditions, pagination behavior (though page_size/page_token are in schema), or how the two actions differ in parameter requirements. For a multi-action tool with rich input schema, more contextual information is needed.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Parameters3/5
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
Schema description coverage is 67%, with 9 parameters. The description mentions the two actions (create, list) which correspond to the 'action' parameter, but doesn't explain how other parameters relate to these actions (e.g., which parameters are required for create vs list). It adds minimal value beyond what the schema already documents through parameter descriptions.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Purpose4/5
Does the description clearly state what the tool does and how it differs from similar tools?
The description clearly states the tool's purpose as '飞书任务的子任务管理工具' (Feishu task subtask management tool) and specifies two actions: create subtasks and list subtasks. It distinguishes this from other task-related tools like feishu_task_task by focusing specifically on subtasks. However, it doesn't explicitly differentiate from all sibling tools beyond the task domain.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Usage Guidelines3/5
Does the description explain when to use this tool, when not to, or what alternatives exist?
The description provides some usage context with '当用户要求创建子任务、查询任务的子任务列表时使用' (use when user requests to create subtasks or query task subtask lists), which implies when to use this tool. However, it doesn't provide explicit guidance on when NOT to use it or mention alternatives among the many sibling tools (like feishu_task_task for main tasks). The guidance is present but incomplete.
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. It mentions acting 'as the user' and that the 'list' action returns only tasks the user is responsible for, adding some context. However, it fails to disclose critical behavioral traits such as authentication needs, rate limits, error handling, or mutation effects (e.g., whether updates are reversible). The description is insufficient for a multi-action tool with potential write operations.
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, starting with the tool's purpose and key actions. The time format note is relevant but could be integrated more smoothly. No redundant sentences; each part adds value, though the structure is slightly fragmented with bracketed text and a list.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Completeness2/5
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
Given the tool's complexity (15 parameters, multiple actions, no output schema, and no annotations), the description is inadequate. It lacks details on return values, error conditions, authentication, and action-specific parameter requirements. For a versatile tool with create/update capabilities, more comprehensive guidance is needed to ensure correct usage.
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 73%, so the schema documents most parameters well. The description adds minimal value beyond the schema: it reiterates the time format (already in schema) and lists action names (in schema enum). It doesn't explain parameter interactions (e.g., which params are needed for each action) or provide usage examples, leaving gaps despite moderate schema coverage.
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 as a 'Feishu task management tool for creating, querying, and updating tasks' with specific actions listed (create, get, list, patch). It distinguishes itself from sibling tools like feishu_task_comment or feishu_task_subtask by focusing on core task operations, though it doesn't explicitly contrast with all siblings.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Usage Guidelines3/5
Does the description explain when to use this tool, when not to, or what alternatives exist?
The description implies usage through the listed actions (e.g., 'list' returns only tasks the user is responsible for) and mentions time format requirements, but lacks explicit guidance on when to use this tool versus alternatives like feishu_task_subtask or calendar tools. No when-not-to-use scenarios or prerequisites are provided.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
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. While it explains the tool's operations and some conceptual relationships (node_token vs obj_token), it doesn't address critical behavioral aspects: which operations are read-only vs. mutating, authentication requirements, rate limits, error conditions, or what the response format looks like. For a multi-operation tool with 13 parameters and no annotations, this represents significant gaps in behavioral transparency.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Conciseness4/5
Is the description appropriately sized, front-loaded, and free of redundancy?
The description is reasonably concise with three sentences that cover the tool's purpose, operations, node concepts, and token relationships. It's front-loaded with the essential information. While efficient, it could be slightly more structured by grouping related concepts or using bullet points for the five operations.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Completeness2/5
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
Given the tool's complexity (13 parameters, 5 distinct operations, no annotations, no output schema), the description is insufficiently complete. It doesn't explain how different operations map to different parameter requirements, what the return values look like, error handling, or operational constraints. For a multi-function tool managing knowledge base nodes, this level of documentation leaves too many gaps for effective agent use.
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 high at 92%, so the schema already documents most parameters well. The description adds some conceptual context about node_token and obj_token relationships, and mentions node types, but doesn't provide additional parameter-specific guidance beyond what's in the schema. The baseline of 3 is appropriate given the high schema coverage, though the description could have better explained which parameters apply to which actions.
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 this is a '飞书知识库节点管理工具' (Feishu knowledge base node management tool) and lists the five specific operations (list, get, create, move, copy). It explains that nodes are documents in the knowledge base including various types like doc, bitable, sheet, etc. However, it doesn't explicitly differentiate this tool from sibling tools like 'feishu_wiki_space' or 'feishu_search_doc_wiki' - it just describes what the tool does without sibling comparison.
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 by explaining node types and the relationship between node_token and obj_token, and mentions that 'get' operation can convert wiki-type node_token to obj_token. However, it doesn't provide explicit guidance on when to use this tool versus alternatives like 'feishu_wiki_space' or 'feishu_search_doc_wiki', nor does it specify prerequisites or when-not-to-use scenarios.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
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. While it lists the available actions and notes parameter distinctions, it doesn't disclose important behavioral traits like authentication requirements, rate limits, error handling, or what happens during deletions. For a tool with 14 parameters and multiple mutation actions, this represents significant gaps in behavioral transparency.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Conciseness3/5
Is the description appropriately sized, front-loaded, and free of redundancy?
The description is reasonably structured with action listings and warnings, but contains some redundancy (repeating action names that are already in the schema enum) and could be more front-loaded. The Chinese text adds localization but doesn't necessarily improve conciseness for an AI agent.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Completeness2/5
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
For a complex tool with 14 parameters, no annotations, no output schema, and multiple mutation capabilities (create/update/delete), the description is incomplete. It lacks information about return values, error conditions, authentication requirements, and important behavioral constraints that would help an agent use this tool effectively.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Parameters3/5
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
The schema description coverage is 93%, so the schema already documents most parameters thoroughly. The description adds minimal value beyond what's in the schema - it lists the available actions and notes the distinction between 'fields' for single create and 'records' for batch create, but doesn't provide additional semantic context for the 14 parameters.
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 manages Feishu Bitable records (rows) for create/query/update/delete/search operations, providing a specific verb+resource combination. However, it doesn't explicitly distinguish this multi-action tool from its sibling tools (bitableCreateRecord, bitableListRecords, bitableUpdateRecord) that appear to handle individual operations separately.
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 ('当用户要求创建/查询/更新/删除记录、搜索数据时使用'), which covers the main use cases. It doesn't explicitly state when NOT to use it or mention alternatives among the sibling tools, though the parameter distinctions between create and batch_create are noted.
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. While it mentions the tool operates '以用户身份' (as the user identity), it doesn't describe authentication requirements, rate limits, error conditions, what happens during updates (overwrite vs merge), or response formats. For a multi-action tool with mutation capabilities (create/patch), this leaves significant behavioral gaps unexplained.
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 in three parts: identity context, usage trigger, and action list. Each sentence serves a distinct purpose with no wasted words. However, the Chinese brackets 【】around the identity statement are slightly unconventional, and the action list could be more elegantly integrated, preventing a perfect score.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Completeness2/5
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
For an 8-parameter tool with no annotations and no output schema, the description is insufficiently complete. It doesn't explain the multi-action nature's implications (how parameters vary by action), doesn't describe return values or error handling, and provides minimal behavioral context for mutation operations. The 75% schema coverage helps, but the description doesn't adequately compensate for the missing structural information.
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 75%, providing a solid baseline. The description adds minimal parameter semantics beyond the schema - it mentions '切换展示方式' (switch display methods) which loosely relates to the view_type parameter with its enum values (grid, kanban, etc.), but doesn't explain when each view_type is appropriate or how parameters interact across different actions. The description doesn't compensate for the 25% coverage gap, so it earns the baseline 3.
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: '飞书多维表格视图管理工具' (Feishu multi-dimensional table view management tool) with specific actions listed (create, get, list, patch). It distinguishes itself from sibling tools like feishu_bitable_app_table_record (which handles records) and feishu_bitable_app_table_field (which handles fields) by focusing specifically on views. 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 Guidelines4/5
Does the description explain when to use this tool, when not to, or what alternatives exist?
The description provides clear usage context: '当用户要求创建/查询/更新视图、切换展示方式时使用' (use when users request to create/query/update views, switch display methods). It lists the specific actions available (create, get, list, patch) which helps guide selection. However, it doesn't explicitly state when NOT to use this tool or name specific alternative tools for related operations, preventing a score of 5.
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 mentions the tool returns document title and Markdown format content with pagination support, which covers basic output behavior. However, it doesn't disclose important behavioral traits like authentication requirements, rate limits, error conditions, whether it's read-only or has side effects, or what happens with invalid doc_id formats. The description is functional but lacks comprehensive behavioral context.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Conciseness5/5
Is the description appropriately sized, front-loaded, and free of redundancy?
The description is extremely concise at just two sentences that directly state the tool's purpose and key capability. Every word earns its place: the first sentence covers what the tool does and what it returns, the second sentence adds the important pagination feature. No wasted words or redundant information.
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 3 parameters with 100% schema coverage but no annotations and no output schema, the description provides adequate but minimal context. It covers the basic purpose and pagination feature but doesn't address authentication, error handling, or detailed output format beyond 'Markdown格式内容'. For a document retrieval tool with no output schema, more detail about the return structure would be helpful.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Parameters3/5
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
Schema description coverage is 100%, so the schema already fully documents all three parameters (doc_id, offset, limit) with their descriptions, types, and constraints. The description adds no additional parameter semantics beyond what's in the schema. The baseline score of 3 is appropriate when the schema does all the parameter documentation work.
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 fetches Feishu cloud document content and returns title and Markdown format, with specific mention of pagination support for large documents. It distinguishes from siblings like feishu_create_doc and feishu_update_doc by focusing on retrieval rather than creation/modification. However, it doesn't explicitly differentiate from docxGetRawContent which might have overlapping functionality.
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 '支持分页获取大文档' (supports pagination for large documents), suggesting this tool should be used when dealing with large documents that need pagination. However, it doesn't provide explicit guidance on when to use this versus alternatives like docxGetRawContent or feishu_search_doc_wiki, nor does it mention any prerequisites or exclusions.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Behavior2/5
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
No annotations are provided, so the description carries the full burden of behavioral disclosure. It mentions actions (create, list, get) but lacks details on permissions required, rate limits, error handling, or what the tool returns (e.g., format of comments). For a tool with multiple actions and no annotations, this is a significant gap in transparency.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Conciseness4/5
Is the description appropriately sized, front-loaded, and free of redundancy?
The description is concise and front-loaded with the tool's purpose and usage context in two sentences. However, the inclusion of 'Actions: create, list, get' is somewhat redundant since the schema already defines the 'action' parameter with these enums, slightly reducing efficiency.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Completeness2/5
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
Given the complexity (9 parameters, no annotations, no output schema), the description is incomplete. It lacks details on behavioral traits (e.g., side effects, authentication), doesn't explain the return values or error cases, and doesn't fully guide parameter usage across different actions. For a multi-action tool with no structured output, this is inadequate.
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 high (89%), so the baseline is 3. The description doesn't add meaningful parameter semantics beyond what the schema provides (e.g., it doesn't explain how parameters like 'action' map to different behaviors or dependencies between parameters). It lists actions but doesn't detail which parameters are required for each action.
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: '飞书任务评论管理工具' (Feishu task comment management tool) with specific actions (create, list, get). It distinguishes itself from sibling tools like feishu_task_task or feishu_task_subtask by focusing on comments. However, it doesn't explicitly differentiate from feishu_doc_comments, which might handle comments on documents rather than tasks.
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 the tool: '当用户要求添加/查询任务评论、回复评论时使用' (when users request to add/query task comments, reply to comments). It specifies the actions (create, list, get) but doesn't explicitly state when to choose this tool over alternatives like feishu_doc_comments or mention prerequisites (e.g., authentication).
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 full behavioral disclosure burden. It describes the three action types and provides important implementation notes about obtaining space_id. However, it doesn't mention authentication requirements, rate limits, error conditions, or what happens during creation (e.g., permissions, default settings). The description adds some behavioral context but leaves significant gaps for a multi-action tool.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Conciseness4/5
Is the description appropriately sized, front-loaded, and free of redundancy?
The description is reasonably concise with three sentences that each serve a purpose: stating the tool's purpose, listing actions, and providing important implementation notes. It's front-loaded with the core functionality. The Chinese/English mixing is slightly distracting but doesn't significantly impact clarity. No wasted sentences, though it could be more 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?
For a 6-parameter tool with no annotations and no output schema, the description provides basic context about actions and space_id sourcing. However, it doesn't explain return values, error handling, or action-specific requirements. Given the complexity (multiple actions with different parameter needs) and lack of structured behavioral annotations, the description should do more to guide proper usage across all three action types.
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 high (83%), so the baseline is 3. The description doesn't add parameter semantics beyond what's in the schema - it mentions space_id sourcing but doesn't explain parameter dependencies (e.g., which parameters are required for which actions). The schema already documents most parameters well, so the description's minimal parameter guidance is adequate but not additive.
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: '飞书知识空间管理工具' (Feishu knowledge space management tool) and lists three specific actions (list, get, create). It distinguishes this tool from siblings like 'feishu_wiki_space_node' by focusing on space-level operations rather than node-level. However, it doesn't explicitly differentiate from other wiki/search tools in the sibling list.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Usage Guidelines3/5
Does the description explain when to use this tool, when not to, or what alternatives exist?
The description provides some usage context: '当用户要求查看知识库列表、获取知识库信息、创建知识库时使用' (use when users request to view knowledge base lists, get knowledge base information, or create knowledge bases). It also offers important notes about obtaining space_id. However, it doesn't specify when to choose this tool over alternatives like 'feishu_search_doc_wiki' or clarify boundaries between space management and document operations.
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. While it lists actions (create, get, list, tasks, patch, add_members), it doesn't describe important behavioral traits like authentication requirements, rate limits, error conditions, or what happens during mutations (e.g., whether updates are reversible). For a multi-action tool with no annotation coverage, this leaves significant gaps in understanding how the tool behaves.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Conciseness5/5
Is the description appropriately sized, front-loaded, and free of redundancy?
The description is efficiently structured in two sentences: first stating the tool's purpose and usage context, then listing all available actions. Every element serves a purpose with zero wasted words, 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.
Completeness3/5
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
Given the tool's complexity (7 parameters, 6 actions) and lack of both annotations and output schema, the description is minimally adequate. It covers what the tool does and when to use it, but doesn't address behavioral aspects, return values, or error handling. For a multi-action tool without structured support, this leaves the agent with incomplete operational understanding.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Parameters3/5
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
Schema description coverage is high at 86%, so the schema already documents most parameters well. The description doesn't add meaningful parameter semantics beyond what's in the schema—it just lists action names without explaining their parameter dependencies or usage patterns. With high schema coverage, the baseline is 3 even without additional param info in the description.
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: '飞书任务清单管理工具' (Feishu task list management tool) with specific actions like create, get, list, tasks, patch, add_members. It distinguishes itself from sibling tools like feishu_task_task (individual tasks) and feishu_task_subtask by focusing on task lists rather than individual tasks. However, it doesn't explicitly differentiate from all siblings in the same domain.
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: '当用户要求创建/查询/管理清单、查看清单内的任务时使用' (when users request creating/querying/managing lists, viewing tasks within lists). It doesn't explicitly mention when NOT to use it or name specific alternatives among sibling tools, but the context is sufficiently clear for an agent to understand its primary use cases.
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 covers basic functionality. It doesn't disclose whether this requires authentication, rate limits, error conditions, what happens on success/failure, or whether messages are delivered synchronously/asynchronously. For a messaging tool with zero annotation coverage, this leaves significant behavioral gaps.
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 in a single sentence that packs essential information about targets, parameters, and content format. Every element serves a purpose, though the Chinese/English mix and technical density could be slightly improved for clarity.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Completeness3/5
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
For a 5-parameter messaging tool with no annotations and no output schema, the description covers core functionality adequately but lacks important context. It explains what parameters do but doesn't address authentication needs, error handling, response format, or integration considerations that would help an agent use it 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?
With only 20% schema description coverage, the description compensates well by explaining the relationship between receive_id_type and receive_id, listing all msg_type options, and providing a concrete example for content parameter. It adds substantial meaning beyond the minimal schema documentation, though doesn't cover the uuid parameter.
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 ('发送一条消息' - send a message) and the resource ('飞书 IM' - Feishu IM), specifying it can send to various targets (chat/user/email/open_id/union_id). It distinguishes itself from sibling tools like listMessagesFeishu and replyMessageFeishu by focusing on sending new messages rather than listing or replying to existing ones.
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 by mentioning the different receive_id_type options and msg_type support, but doesn't explicitly state when to use this tool versus alternatives like sendCardFeishu or replyMessageFeishu. It provides technical parameters but lacks explicit guidance on use-case scenarios or prerequisites.
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 full burden. It discloses key behavioral traits: authentication context ('以用户的身份' - as a user), exclusion of bot members, and that it returns member information including ID and name. However, it doesn't mention pagination behavior (implied by parameters but not described), rate limits, error conditions, or what happens with invalid chat_id.
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 with two sentences. The first sentence states the core purpose and authentication context, while the second adds important behavioral constraint about bot members. It's front-loaded with essential information and avoids unnecessary elaboration.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Completeness3/5
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
For a read operation with 4 parameters, 75% schema coverage, and no output schema, the description provides adequate but incomplete context. It covers the main purpose and a key constraint (no bot members), but lacks details about return format beyond '成员信息，包含成员 ID、姓名等' (member information including ID, name, etc.), pagination behavior, or error handling.
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 75% (3 of 4 parameters have descriptions), so the baseline is 3. The description adds value by implicitly explaining the chat_id parameter's purpose ('获取指定群组的成员列表' - get member list of specified group) and the member information returned, which helps understand the tool's overall function beyond individual parameters.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Purpose5/5
Does the description clearly state what the tool does and how it differs from similar tools?
The description clearly states the specific action ('获取指定群组的成员列表' - get member list of specified group), resource ('群组' - group), and scope ('以用户的身份' - as a user). It distinguishes from potential siblings by specifying it returns human members only ('不会返回群组内的机器人成员' - won't return bot members), which is a unique constraint not implied by the tool name alone.
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 ('以用户的身份' - as a user) but doesn't explicitly state when to use this tool versus alternatives. Among siblings, there's no direct alternative for fetching chat members, so the lack of explicit comparison is understandable, but no guidance on prerequisites or exclusions is 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 full burden. It discloses that actions include read operations (list, list_replies) and write operations (create, reply, patch), and mentions wiki token support. However, it doesn't cover important behavioral aspects like authentication requirements, rate limits, error conditions, or what the return values look like for each action type.
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 opening statement followed by enumerated actions. Every sentence earns its place by explaining capabilities. It could be slightly more front-loaded with the core purpose, but overall it's well-organized without wasted 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?
For a complex tool with 11 parameters, no annotations, and no output schema, the description provides adequate but incomplete coverage. It explains the five action types and wiki token support, but doesn't address return values, error handling, or detailed behavioral expectations for each action. Given the complexity, more comprehensive guidance would be helpful.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Parameters3/5
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
Schema description coverage is high (82%), so the baseline is 3. The description adds some value by explaining that actions include list, create, reply, and patch operations, and mentions wiki token support. However, it doesn't provide additional parameter semantics beyond what's already well-documented in the schema descriptions for most parameters.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Purpose5/5
Does the description clearly state what the tool does and how it differs from similar tools?
The description clearly states the tool's purpose: '管理云文档评论' (manage cloud document comments) with specific verbs for each action (list, create, reply, patch). It distinguishes itself from siblings like feishu_task_comment by focusing on document comments rather than task comments, and from feishu_doc_media by handling comments rather than media.
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 each action (list, create, reply, patch) and mentions support for wiki tokens. However, it doesn't explicitly state when NOT to use this tool versus alternatives like feishu_task_comment or provide explicit sibling tool comparisons beyond the action differentiation 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 full burden and does well by disclosing key behavioral traits: it warns that write is '高危,请谨慎使用' (high-risk, use cautiously), explains automatic parsing of URLs/tokens for all actions except create, describes default behaviors (e.g., no range reads first sheet entirely), and notes export format constraints. It doesn't cover rate limits, authentication needs, or detailed 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.
Conciseness3/5
Is the description appropriately sized, front-loaded, and free of redundancy?
The description is appropriately sized but not optimally structured: it starts with a general statement, then a product comparison, then action details. Some sentences are redundant (e.g., range info repeated). While informative, it could be more front-loaded with core purpose and key warnings, and some details could be trimmed or integrated more efficiently.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Completeness3/5
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
Given the tool's complexity (18 parameters, no output schema, no annotations), the description is moderately complete. It covers core actions, warnings, and some defaults, but lacks details on return values, error cases, authentication requirements, and comprehensive usage scenarios. It compensates somewhat for the lack of annotations but doesn't fully address all contextual gaps for a multi-action tool.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Parameters3/5
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
Schema description coverage is high at 94%, so the baseline is 3. The description adds some value by clarifying parameter usage in context (e.g., URL vs spreadsheet_token parsing, range defaults, sheet_id for csv export), but doesn't extensively explain semantics beyond what the schema descriptions already cover for most parameters.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Purpose5/5
Does the description clearly state what the tool does and how it differs from similar tools?
The description clearly states the tool's purpose as a Feishu spreadsheet tool supporting create, read/write, find, and export operations. It explicitly distinguishes from sibling tools by noting that spreadsheets are different from bitable/airtable products, and lists 7 specific actions with brief explanations, making the purpose highly specific and differentiated.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Usage Guidelines4/5
Does the description explain when to use this tool, when not to, or what alternatives exist?
The description provides clear context about when to use certain features (e.g., '除 create 外' for URL parsing, 'csv 必须指定 sheet_id' for export), and distinguishes spreadsheets from bitables. However, it doesn't explicitly state when to choose this tool over sibling tools like feishu_bitable_app or feishu_drive_file, missing explicit alternatives or exclusions.
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. It discloses key behavioral traits: it's a polling operation that blocks until timeout, automatically persists tokens on success, and returns open_id. It also mentions the device_code source from lark_oauth_start. However, it doesn't detail error handling, rate limits, or what happens on failure beyond timeout.
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 concise and front-loaded: the first sentence states the core purpose, and subsequent sentences add necessary context about persistence and parameter source. Every sentence earns its place with no wasted words, and the structure is logical for a tool description.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Completeness3/5
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
Given the tool's complexity (OAuth polling with persistence) and no annotations or output schema, the description is moderately complete. It covers the purpose, usage flow, and key behaviors, but lacks details on error responses, what '超时' (timeout) specifically entails, or the format of returned open_id. For a tool with no structured output, more context on return values would be helpful.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Parameters3/5
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
Schema description coverage is 50% (only poll_timeout_sec has a description). The description adds value by explaining device_code comes from lark_oauth_start, which clarifies its semantics beyond the schema's minLength constraint. For poll_timeout_sec, the schema already describes it well, so the description doesn't add much. Baseline 3 is appropriate as the description partially compensates for the coverage gap.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Purpose4/5
Does the description clearly state what the tool does and how it differs from similar tools?
The description clearly states the tool's purpose: '轮询 Device Flow 的 token 端点,直到用户在浏览器完成授权或超时' (poll the Device Flow token endpoint until user completes authorization or timeout). It specifies the verb (poll) and resource (token endpoint), though it doesn't explicitly differentiate from sibling tools like lark_oauth_start or lark_oauth_status beyond mentioning the device_code source.
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: after lark_oauth_start returns a device_code, to poll until authorization completes. It mentions '成功后自动持久化 user_access_token 并返回 open_id' (upon success, automatically persists user_access_token and returns open_id), which helps understand the outcome. However, it doesn't explicitly state when not to use it or compare with alternatives like lark_oauth_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 full burden for behavioral disclosure. It mentions the tool operates 'as the user' (implying user-level permissions) and lists the four action types, but doesn't describe authentication requirements, rate limits, error conditions, or what happens when fields are deleted. The description adds basic operational context but lacks deeper behavioral details.
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 in two sentences: first establishes context and purpose, second lists the four actions. Every phrase adds value with no wasted words. It could be slightly more front-loaded by moving the action list earlier, but overall it's well-organized and 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?
For a 10-parameter tool with no annotations and no output schema, the description provides adequate basic context about purpose and actions. However, it doesn't explain return values, error handling, or complex parameter interactions (like how property interacts with type). Given the tool's complexity and lack of structured metadata, the description should provide more complete operational guidance.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Parameters4/5
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
The schema has 90% description coverage, so the baseline is 3. The description adds value by explicitly listing the four action types (create, list, update, delete) which helps the agent understand the primary parameter 'action'. However, it doesn't explain parameter dependencies or provide additional context beyond what's already in the well-documented 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 (create/query/update/delete fields) and resource (Feishu Bitable app table fields). It distinguishes this tool from sibling tools like bitableCreateRecord (records) and feishu_bitable_app_table (tables) by focusing specifically on field/column management.
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 ('when user requests create/query/update/delete fields, adjust table structure'). However, it doesn't explicitly state when NOT to use it or name specific alternatives among the many sibling tools, which would be needed for a perfect score.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Behavior3/5
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
With no annotations provided, the description carries the full burden of behavioral disclosure. It adds useful context beyond basic functionality, such as highlighting that results include titles and summaries with keyword highlighting (<h> tags), and notes on filtering behavior (e.g., applying the same filter to both documents and wikis). However, it lacks details on permissions, rate limits, error handling, or pagination behavior (though pagination is hinted at via parameters), leaving some gaps in transparency.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Conciseness4/5
Is the description appropriately sized, front-loaded, and free of redundancy?
The description is appropriately sized and front-loaded, starting with the tool's purpose and key actions. It uses bullet-point-like emphasis (【重要】) to highlight critical information, making it easy to scan. However, some sentences are slightly repetitive (e.g., repeating filter behavior), and the structure could be more streamlined, preventing a perfect score of 5.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Completeness3/5
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
Given the tool's complexity (5 parameters, nested objects, no output schema, and no annotations), the description is moderately complete. It covers the main purpose, key parameters, and result formatting, but lacks details on output structure, error cases, authentication needs, or performance limits. Without annotations or an output schema, these gaps make it adequate but not fully comprehensive for an agent to handle all scenarios.
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 high (80%), so the baseline is 3. The description adds meaningful semantics beyond the schema by emphasizing the importance of the 'query' and 'filter' parameters, explaining that 'filter' applies to both documents and wikis when used, and listing examples of filter dimensions (e.g., document type, creator, creation time). This provides practical guidance that enhances understanding, though it doesn't cover all parameters in depth, such as 'page_token' or 'page_size'.
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: '飞书文档与 Wiki 统一搜索工具。同时搜索云空间文档和知识库 Wiki。Actions: search.' It specifies the exact verb ('search') and resources ('云空间文档和知识库 Wiki'), and distinguishes itself from siblings by focusing on unified search across documents and wikis, unlike other tools that handle specific operations like creating, updating, or listing individual resources.
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: for searching documents and wikis in Feishu. It mentions that the 'query' parameter is required and 'filter' is optional, with guidance on how filtering works. However, it does not explicitly state when not to use it or name alternative tools for similar functions, such as 'feishu_search_user' for user searches, which limits the score to 4.
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 the tool's dual behavior (current vs. specified user) and lists return fields (name, avatar, email, phone, department), which adds useful context. However, it doesn't mention authentication requirements, rate limits, error conditions, or whether this is a read-only operation (though implied by 'get'), leaving some behavioral gaps.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Conciseness5/5
Is the description appropriately sized, front-loaded, and free of redundancy?
The description is front-loaded with the core purpose, followed by conditional usage and return details in two concise sentences. Every sentence adds value without redundancy, making it efficient and easy to parse for an AI agent.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Completeness3/5
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
Given no annotations and no output schema, the description provides basic purpose, usage, and return fields, which is adequate for a simple lookup tool. However, it lacks details on authentication, error handling, or data format specifics, which could be important for robust agent operation. It's minimally complete but has room for improvement.
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 50% (only user_id has a description). The description compensates by explaining the semantics of user_id (when to omit it for current user info) and implies the purpose of user_id_type through context. It adds meaning beyond the schema, especially for user_id, though it could elaborate more on user_id_type's role.
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 ('获取' meaning 'get') and resource ('用户信息' meaning 'user information'). It distinguishes between two modes: getting current user info when no user_id is provided, and getting specified user info when user_id is provided. This is precise and actionable.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Usage Guidelines4/5
Does the description explain when to use this tool, when not to, or what alternatives exist?
The description provides clear context on when to use each mode (with or without user_id), which helps the agent understand the tool's behavior. However, it doesn't explicitly mention when to use this tool versus sibling tools like 'feishu_search_user', which could help differentiate between lookup and search operations. The guidance is good but lacks sibling comparison.
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 that this is a batch authorization tool, implying it performs a write/mutation operation (granting permissions). However, it lacks details on behavioral traits such as what specific permissions are granted, whether this requires admin privileges, potential rate limits, or what happens if authorization fails. The description adds some context (e.g., it's for 'all user permissions'), but more behavioral transparency would be helpful given the absence of annotations.
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 concise and well-structured: two sentences that clearly state the purpose and usage guidelines without any wasted words. It is front-loaded with the core functionality and follows with specific conditions for use, making it efficient and easy to parse.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Completeness4/5
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
Given the tool's complexity (a batch authorization operation with no parameters), the description is reasonably complete. It explains what the tool does and when to use it. However, without annotations or an output schema, it lacks details on behavioral aspects (e.g., success/failure responses, side effects). For a mutation tool with no structured data support, the description does a good job but could be more comprehensive about outcomes or errors.
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, and the schema description coverage is 100%. With no parameters, the baseline is 4. The description doesn't need to explain parameters, and it doesn't add any parameter-specific information beyond what the schema provides (which is minimal since there are no parameters). This score reflects that the description is adequate for a parameterless tool.
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: '飞书批量授权工具，一次性授权应用已开通的所有用户权限' (Feishu batch authorization tool, authorizes all user permissions for the application at once). It specifies the verb ('授权' - authorize) and resource ('应用已开通的所有用户权限' - all user permissions for the application), making the purpose clear. However, it doesn't explicitly differentiate from sibling tools like 'feishu_oauth' or 'lark_oauth_complete', which may handle different authorization scenarios.
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 guidelines: '仅在用户明确要求'授权所有权限'、'一次性授权'时使用' (Only use when the user explicitly requests 'authorize all permissions' or 'one-time authorization'). It clearly states when to use this tool (on explicit user request) and implies when not to use it (e.g., for partial or incremental authorization, which might be handled by other tools like 'feishu_oauth'). This is a strong, directive guideline.
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 full burden. It discloses the tool's behavior well: it's a read-only status check (implied by '查询'), describes the return values clearly (has_token/access_expired/refresh_expired/expires_in_sec), and mentions the default identity fallback. However, it doesn't cover potential error cases, rate limits, or authentication requirements for the tool itself.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Conciseness5/5
Is the description appropriately sized, front-loaded, and free of redundancy?
The description is perfectly concise: one sentence that efficiently communicates purpose, default behavior, and return values. Every element earns its place with zero wasted words, and the information is front-loaded with the core functionality.
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?
For a simple status-check tool with one optional parameter and no output schema, the description provides excellent coverage: purpose, usage context, return values, and default behavior. The only minor gap is lack of explicit error handling or edge case information, but for this tool's complexity, it's nearly complete.
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 100% with one optional parameter, so baseline is 3. The description adds meaningful context by explaining the default behavior when open_id is omitted ('默认为 app 所有者'), which clarifies the tool's semantics beyond the schema's technical specification. This elevates the score above baseline.
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 ('查询' - query/check) and resource ('Feishu 用户... user_access_token'), with precise scope about defaulting to app owner. It distinguishes from siblings like lark_oauth_start (initiates OAuth) and lark_oauth_revoke (revokes tokens) by focusing on status checking only.
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 about when to use this tool: to check OAuth token status for a Feishu user. It implicitly suggests using this before operations requiring user_access_token, though it doesn't explicitly name alternatives or state when NOT to use it. The parameter description mentions the default behavior when open_id is omitted.
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 does well by specifying the batch query capability (1-10 users) and that it queries primary calendars. However, it doesn't mention authentication requirements, rate limits, error conditions, or what the output format looks like. For a tool with no annotations, this leaves significant behavioral gaps.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Conciseness5/5
Is the description appropriately sized, front-loaded, and free of redundancy?
The description is perfectly concise with three sentences that each earn their place: first establishes identity and purpose, second specifies when to use, third details capabilities and practical application. No wasted words, front-loaded with the core purpose.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Completeness3/5
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
For a tool with 4 parameters, no annotations, and no output schema, the description does reasonably well but has gaps. It covers the 'what' and 'when' effectively but lacks details about authentication, error handling, rate limits, and output format. The description is complete enough for basic understanding but insufficient for robust agent operation without additional 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 context beyond the 75% schema coverage. While the schema documents the parameters technically, the description clarifies that 'user_ids' are for '批量查询 1-10 个用户' (batch query 1-10 users) and that the tool is specifically for '安排会议时间' (scheduling meeting times). This provides practical usage context that the schema alone doesn't convey.
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 ('查询忙闲', '查看忙闲状态') and resources ('飞书日历', '用户的主日历忙闲信息'). It distinguishes itself from sibling tools like calendarListEvents or feishu_calendar_event by focusing specifically on free/busy status queries rather than event details or calendar listings.
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 guidelines: '当用户要求查询某时间段内某人是否空闲、查看忙闲状态时使用' (when users request checking availability within a time period). It also specifies the scope ('支持批量查询 1-10 个用户的主日历忙闲信息') and purpose ('用于安排会议时间'), giving clear context for when to use this tool.
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: the tool downloads resources to a specific local directory (/tmp/openclaw/), returns a saved_path in the response, and handles both images and files. However, it doesn't mention potential errors, rate limits, or authentication requirements, leaving some gaps.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Conciseness4/5
Is the description appropriately sized, front-loaded, and free of redundancy?
The description is well-structured and appropriately sized, with clear sections for purpose, usage scenarios, and behavioral details. Every sentence adds value, though it could be slightly more concise by integrating some details more tightly without losing clarity.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Completeness4/5
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
Given the tool's complexity (3 required parameters, no output schema, no annotations), the description does a good job covering purpose, usage, and key behaviors like file saving and return values. However, it lacks details on error handling, file size limits, or format specifics, which could be important for a download tool.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Parameters3/5
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
Schema description coverage is 100%, so the schema already documents all three parameters thoroughly. The description adds minimal value beyond the schema by reinforcing the context for message_id extraction and mentioning image_key/file_key, but doesn't provide additional syntax or format details. Baseline 3 is appropriate when the schema does the heavy lifting.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
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 ('download') and resources ('image or file resources from Feishu IM messages to local'), and distinguishes it from sibling tools by specifying its unique role in handling bot-received messages with message_id and image_key/file_key from the current conversation context.
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 scenarios ('user messages to bot, referenced messages, group chat messages to bot'), specifies when to use it ('current conversation context with message_id and image_key/file_key'), and gives practical guidance on extracting message_id from context without asking the user, making it highly actionable.
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 critical behavioral traits: requires user OAuth authorization, saves files automatically to /tmp/openclaw/, returns saved_path, has a 100MB file size limit, and lists unsupported resource types (emojis, merged-forward messages, card resources). This covers most key operational aspects.
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 scenarios, notes, parameter explanation, file handling, limitations). It's appropriately sized for a tool with multiple behavioral constraints, though some redundancy with schema descriptions slightly reduces efficiency.
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?
For a tool with no annotations and no output schema, the description provides comprehensive context: purpose, usage rules, authorization needs, file handling behavior, return value hint (saved_path), and limitations. It effectively compensates for the lack of structured metadata, though minor details like error handling could be more explicit.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Parameters3/5
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
Schema description coverage is 100%, so the baseline is 3. The description adds minimal value beyond the schema: it clarifies that file_key comes from message bodies and distinguishes image_key vs. file_key, but this is largely redundant with schema descriptions. No significant semantic enhancements 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 ('download') and resources ('file or image resources from Feishu IM messages to local file'), distinguishing it from sibling tools like feishu_im_bot_image. It explicitly mentions the user OAuth requirement, which adds specificity beyond just the action.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Usage 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 have message_id and file_key from user-identity APIs') and when not to use it ('if message_id is from current conversation context, use feishu_im_bot_image instead'). It names the alternative tool and specifies the authorization difference, making it highly actionable.
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 important behavioral traits: authentication context ('以用户身份'), pagination behavior, time filtering options, parameter constraints (mutual exclusivity rules), and return format details. It doesn't mention rate limits, permissions needed, or error conditions, but covers most essential operational aspects.
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 (usage, parameter constraints, return format) and every sentence adds value. It's appropriately sized for an 8-parameter tool with complex constraints. The only minor issue is some redundancy with schema descriptions, but overall it's efficient and front-loaded with the core purpose.
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?
For a complex message retrieval tool with 8 parameters, no annotations, and no output schema, the description provides good coverage. It explains authentication context, parameter constraints, filtering options, pagination, and return format. It doesn't cover error cases or rate limits, but given the schema's 100% description coverage and the detailed behavioral context provided, it's mostly complete.
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 100%, so the baseline is 3. The description adds significant value beyond the schema by explaining the semantic relationships between parameters: 'open_id 和 chat_id 必须二选一' (must choose one), 'relative_time 和 start_time/end_time 不能同时使用' (cannot use together), and clarifying that open_id '自动解析 chat_id' (automatically resolves to chat_id). It also provides practical examples of relative_time formats.
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: '获取群聊或单聊的历史消息' (get historical messages from group or private chats). It specifies the verb ('获取' - get/retrieve) and resource ('历史消息' - historical messages), and distinguishes itself from siblings like 'feishu_im_user_search_messages' (search messages) by focusing on retrieval from specific chats rather than searching across chats.
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 usage context: '以用户身份' (as a user identity) and explains how to use chat_id vs open_id for different chat types. However, it doesn't explicitly mention when to use this tool versus alternatives like 'feishu_im_user_search_messages' (search messages) or 'listMessagesFeishu', which appears to be a similar tool. The guidance is good but lacks sibling differentiation.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Behavior4/5
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
With no annotations provided, the description carries full burden and does well by disclosing key behavioral traits: it specifies the tool operates '以用户身份' (as user identity), mentions pagination behavior, reveals the API limitation about time range filtering, and describes the return format. However, it doesn't mention rate limits, authentication requirements, or error conditions that would be helpful for a complete behavioral picture.
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 statement, usage instructions, and important notes. It's appropriately sized with no wasted sentences, though the Chinese formatting with brackets and bullet points could be slightly more concise. Every sentence adds value, particularly the API limitation warning.
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?
For a read-only list operation with 4 parameters and no output schema, the description provides good contextual completeness. It explains what the tool does, how to use it, important limitations, and the return format. The main gap is the lack of output schema, but the description compensates by stating the return format matches 'feishu_im_user_get_messages', which provides adequate reference.
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 schema description coverage is 100%, so all parameters are documented in the schema. The description adds minimal additional parameter semantics beyond what's in the schema - it only mentions that thread_id uses 'omt_xxx' format and that pagination is supported. This meets the baseline expectation when schema coverage is complete.
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 verb ('获取' meaning 'get') and resource ('话题内的消息列表' meaning 'message list within a thread'), and distinguishes it from sibling tools like 'feishu_im_user_get_messages' by specifying it's for thread messages rather than general messages. The Chinese text '【以用户身份】' (as user identity) further clarifies the access context.
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: it specifies when to use (via thread_id to get all messages in a thread), mentions pagination support, and importantly states when NOT to use by noting '话题消息不支持时间范围过滤' (thread messages don't support time range filtering) due to API limitations. This clearly distinguishes it from tools like 'feishu_im_user_search_messages' that might support filtering.
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 for behavioral disclosure. It effectively describes key behaviors: the two distinct operations (insert/download), file size limits (20MB), supported formats for images, and the important constraint that insert only works with local files. It doesn't mention authentication requirements or rate limits, but covers essential operational constraints.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Conciseness5/5
Is the description appropriately sized, front-loaded, and free of redundancy?
The description is efficiently structured with two clear sections: an overview of the two operations, followed by an important constraint note. Every sentence serves a purpose - the first explains what the tool does, the second provides critical usage guidance. No wasted words or redundant information.
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?
For a tool with 9 parameters, no annotations, and no output schema, the description does well to cover the essential context. It explains the two main operations, their requirements, and key constraints. However, it doesn't describe what the tool returns (output format) or error conditions, which would be helpful given the absence of output schema.
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 high at 89%, so the baseline is 3. The description adds some value by clarifying that 'insert requires document ID + local file path' and 'download requires resource token + output path', but doesn't provide significant additional parameter semantics beyond what's already well-documented in the schema properties.
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 ('insert' and 'download') and resources ('local images or files', 'document materials or whiteboard thumbnails'). It distinguishes this tool from siblings like 'feishu_create_doc' and 'feishu_update_doc' by specifying it handles local file operations rather than URL-based media insertion.
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 versus alternatives. It states 'insert only supports local file paths' and directs users to 'use create-doc/update-doc' for URL images, naming specific sibling tools. This clearly defines the scope and appropriate 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 the full burden of behavioral disclosure. It effectively describes key behavioral traits: the tool performs a destructive operation (revocation), it automatically extracts user context from messages without requiring explicit user_open_id parameter, and it has strict invocation constraints based on user intent. However, it doesn't mention potential side effects like data loss or authentication state changes.
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 zero wasted sentences. It opens with the core purpose, immediately provides usage guidelines with positive and negative examples, and explains the automatic parameter handling. Every sentence serves a clear purpose in guiding the agent's decision-making.
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?
For a single-parameter tool with no output schema and no annotations, the description provides excellent contextual completeness regarding usage scenarios and behavioral constraints. It effectively compensates for the lack of structured annotations. The only minor gap is the absence of information about what happens after revocation or potential error conditions.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Parameters3/5
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
The input schema has 100% description coverage, with the single parameter 'action' clearly documented as 'revoke: 撤销当前用户已保存的授权凭据'. The description adds no additional parameter semantics beyond what's already in the schema, but since schema coverage is complete, the baseline score of 3 is appropriate.
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 as '飞书用户撤销授权工具' (Feishu user authorization revocation tool), specifying the exact action (revoke authorization) and target (Feishu users). It distinguishes itself from sibling tools like 'lark_oauth_start' or 'feishu_oauth_batch_auth' by focusing exclusively on revocation, not initiation or other OAuth operations.
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 guidelines with clear when-to-use examples ('撤销授权', '取消授权', '退出登录', '清除授权') and when-not-to-use scenarios ('重新授权', '发起授权', '授权失败', etc.). It explicitly states that authorization processes are handled automatically by the system and should not be manually invoked, offering clear alternatives for different user intents.
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 traits: it's a destructive operation (deleting tokens), requires a confirmation parameter to prevent accidents, and has downstream effects ('之后该用户的 feishu_* 工具会再次要求授权' meaning 'afterwards, the user's feishu_* tools will require re-authorization'). This adds valuable context beyond basic parameters.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Conciseness5/5
Is the description appropriately sized, front-loaded, and free of redundancy?
The description is front-loaded with the core action and requirements in two concise sentences. Every sentence earns its place: the first states the purpose and mandatory parameter, the second explains the consequence. 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 complexity (destructive OAuth operation with 2 parameters), no annotations, and no output schema, the description is largely complete. It covers purpose, usage, behavioral effects, and parameter intent. However, it lacks details on error cases, response format, or permissions required, leaving minor gaps for a mutation 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?
Schema description coverage is 50% (only 'confirm' has a description). The description compensates by explaining the purpose of 'confirm' ('调用者必须传 confirm=true' and its role in preventing accidental revocation) and implies 'open_id' identifies the user, though it doesn't detail format or constraints. This adds meaningful semantics beyond the schema's minimal coverage.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Purpose5/5
Does the description clearly state what the tool does and how it differs from similar tools?
The description clearly states the specific action ('删除' meaning 'delete' or 'revoke') and the resource ('已存储 user_access_token' meaning 'stored user_access_token'), with explicit mention of the user scope ('指定用户的' meaning 'specified user's'). It distinguishes from siblings like lark_oauth_start or lark_oauth_status by focusing on token revocation rather than initiation or status checking.
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 revoke a user's access token, with the explicit requirement '调用者必须传 confirm=true' (caller must pass confirm=true). However, it does not specify when NOT to use it or name alternatives among siblings (e.g., lark_oauth_status for checking token validity), leaving some guidance gaps.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Behavior4/5
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
No annotations are provided, so the description carries the full burden. It discloses key behavioral traits: it returns an authorization URL and user code, requires user interaction (opening a browser and entering a code), and enables other Feishu tools upon successful authorization. However, it doesn't mention potential errors, rate limits, or authentication requirements beyond the OAuth flow, leaving some gaps.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Conciseness5/5
Is the description appropriately sized, front-loaded, and free of redundancy?
The description is appropriately sized and front-loaded: the first sentence states the core purpose, followed by clear usage instructions and context. Every sentence earns its place by providing essential information without redundancy, making it efficient and well-structured.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Completeness4/5
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
Given the tool's complexity (OAuth flow initiation) and lack of annotations or output schema, the description is mostly complete. It explains the purpose, usage flow, and outcome (enabling other tools), but doesn't detail return values or error handling, which could be helpful for an agent. However, it covers the critical aspects well for its role.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Parameters3/5
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
The input schema has 100% description coverage for its single parameter (scope), so the baseline is 3. The description does not add any parameter-specific information beyond what the schema provides (e.g., it doesn't explain scope usage or examples), but it doesn't need to compensate as schema coverage is high.
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: '启动飞书用户授权的 Device Flow,返回授权 URL 和用户码' (Start Feishu user authorization Device Flow, return authorization URL and user code). It specifies the exact action (start OAuth Device Flow) and resource (Feishu user authorization), and distinguishes itself from sibling tools like lark_oauth_complete, which is mentioned as the next step.
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 guidelines: '使用后请让用户在浏览器打开 verification_uri 并输入 user_code,然后调用 lark_oauth_complete(device_code) 完成授权' (After use, have the user open verification_uri in a browser and enter user_code, then call lark_oauth_complete(device_code) to complete authorization). It clearly states when to use this tool (to start OAuth) and what to do next, including naming the alternative tool (lark_oauth_complete).
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 key behavioral aspects: it describes the multi-action nature (create/list/patch/batch_create), field definition strategies, and the relationship with sibling tools. However, it doesn't mention authentication requirements, rate limits, or error handling, leaving some behavioral gaps.
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 front-loaded with purpose and usage context. The two paragraphs efficiently cover tool scope, actions, and field strategies. While slightly longer than minimal, every sentence adds value without redundancy.
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?
For a complex 8-parameter tool with no annotations and no output schema, the description provides good contextual coverage. It explains the multi-action pattern, field definition approaches, and sibling relationships. However, it doesn't describe return values or error conditions, which would be helpful given the absence of output schema.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Parameters4/5
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
With 75% schema description coverage, the description adds meaningful context beyond the schema. It explains the two field definition approaches (one-time vs. exploratory) and their trade-offs, which helps users understand when to use the 'fields' parameter. However, it doesn't provide additional context for other parameters like page_size or table_id usage.
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: '飞书多维表格数据表管理工具' (Feishu multi-dimensional table data table management tool) with specific actions (create/list/patch/batch_create). It distinguishes itself from sibling tools like feishu_bitable_app_table_field (for field management) and feishu_bitable_app_table_record (for record management) by focusing on table-level operations.
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: '当用户要求创建/查询/管理数据表时使用' (use when users request to create/query/manage data tables). It also offers detailed alternatives for field definition approaches (one-time vs. exploratory) and references the sibling tool feishu_bitable_app_table_field for gradual field modification.
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 does an excellent job describing critical behaviors: the user impersonation context ('以用户身份'), mandatory parameters for visibility ('create must include user_open_id'), automatic expansion of recurring events, time range limits (40 days, 1000 instances), and format requirements (ISO 8601/RFC 3339). It could improve by mentioning error handling or rate limits, but covers most essential behavioral aspects.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Conciseness4/5
Is the description appropriately sized, front-loaded, and free of redundancy?
The description is well-structured with clear sections: purpose statement, usage context, action list, and important notes. While somewhat lengthy due to the tool's complexity, every sentence adds value - no redundant information. It could be slightly more concise but effectively balances completeness with 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 high complexity (21 parameters, no annotations, no output schema), the description does an excellent job providing context. It explains the tool's scope, usage patterns, critical parameters, constraints, and format requirements. The main gap is the lack of output format description, but considering the action-oriented nature and detailed parameter guidance, it's mostly complete for agent usage.
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 90% schema description coverage, the baseline is high. The description adds significant value beyond the schema by explaining parameter semantics in context: it clarifies that 'user_open_id' must come from SenderId for visibility, that 'list' uses 'instance_view' with automatic expansion, and provides format examples. It doesn't cover all 21 parameters but adds crucial context for the most important ones.
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 as a Feishu calendar event management tool with specific verbs (create, list, get, patch, delete, search, reply, instances, instance_view) and resources (calendar events). It explicitly distinguishes itself from sibling tools by focusing on calendar events rather than other Feishu resources like documents, tasks, or chats.
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 guidelines: it specifies when to use the tool ('when user asks to view, create, modify, delete, search schedules, or reply to invitations'), includes important exclusions (e.g., 'create must include user_open_id'), and mentions constraints ('time range cannot exceed 40 days, max 1000 instances'). It also implicitly distinguishes from sibling calendar tools by focusing on events rather than calendars or attendees.
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 behavioral traits like authentication context ('以用户身份'), file handling specifics (e.g., upload prioritizes file_path, download returns Base64 if no output_path), and important constraints (e.g., copy/move/delete need file_token and type). It doesn't mention rate limits or error behaviors, but covers key operational details.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Conciseness4/5
Is the description appropriately sized, front-loaded, and free of redundancy?
The description is well-structured with a purpose statement, usage guidelines, action list, and important notes. It's appropriately sized for a multi-action tool (16 parameters), though some sentences could be more front-loaded (e.g., the action list is detailed but necessary). There's minimal waste, but the Chinese/English mix and bullet points slightly affect flow.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Completeness4/5
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
Given the tool's complexity (multi-action, 16 parameters, no annotations, no output schema), the description is largely complete: it covers purpose, usage, actions, and key parameter semantics. However, it lacks details on return values (e.g., what list returns) and error handling, which would help compensate for the missing output schema. It's sufficient but not exhaustive.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Parameters4/5
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
Schema description coverage is high (94%), so the baseline is 3. The description adds value by clarifying parameter usage beyond the schema: e.g., it explains that folder_token is optional for list actions (root directory if not provided), specifies format examples for request_docs, and details the interplay between file_path/file_content_base64 and file_name/size for upload. This compensates for the minor schema gaps.
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 as '飞书云空间文件管理工具' (Feishu cloud space file management tool) and lists specific actions (list, get_meta, copy, move, delete, upload, download) with their functions. It distinguishes from siblings by explicitly stating when NOT to use it ('消息中的文件读写**禁止**使用该工具!'), making the purpose specific and differentiated.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Usage Guidelines5/5
Does the description explain when to use this tool, when not to, or what alternatives exist?
The description provides explicit usage guidelines: it states when to use ('当用户要求查看云空间(云盘)中的文件列表、获取文件信息、复制/移动/删除文件、上传/下载文件时使用') and when NOT to use ('消息中的文件读写**禁止**使用该工具!'). It also implicitly guides usage among its own actions by describing each action's purpose, though it doesn't name external 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 the full burden of behavioral disclosure. It effectively describes key behavioral traits: the tool acts with user identity ('以用户身份发送消息'), has security constraints requiring user confirmation, includes idempotency handling via the uuid parameter, and specifies content format requirements. However, it doesn't mention rate limits, error handling, or response formats, leaving some gaps in behavioral context.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Conciseness4/5
Is the description appropriately sized, front-loaded, and free of redundancy?
The description is well-structured with clear sections (usage guidelines, actions, important notes, security constraints) and uses bold text for emphasis. Most sentences earn their place by providing essential information, though some redundancy exists (e.g., content format is mentioned multiple times). It's appropriately sized for an 8-parameter tool with complex requirements.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Completeness4/5
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
Given the tool's complexity (8 parameters, no annotations, no output schema), the description provides substantial context: usage rules, action explanations, parameter guidance, and security constraints. It effectively covers the tool's purpose and critical behavioral aspects. However, it lacks details on error responses, rate limits, and specific output formats, which would enhance completeness for such a multifaceted tool.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Parameters4/5
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
The schema description coverage is high (88%), so the baseline is 3. The description adds significant value beyond the schema by explaining parameter semantics in context: it clarifies that 'receive_id_type=open_id' is for private chats and 'receive_id_type=chat_id' for group chats, provides critical guidance on content format ('content 必须是合法 JSON 字符串'), and emphasizes the uuid parameter's idempotency role. This compensates well for the 12% schema coverage gap.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Purpose5/5
Does the description clearly state what the tool does and how it differs from similar tools?
The description clearly states the tool's purpose: '飞书用户身份 IM 消息工具' (Feishu user identity IM message tool) with specific actions 'send（发送消息）' and 'reply（回复消息）'. It explicitly distinguishes from sibling tools by stating '当没有明确要求时优先使用message系统工具' (when not explicitly requested, prioritize using the message system tool), which helps differentiate it from other messaging tools in the sibling list like sendMessageFeishu and replyMessageFeishu.
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 guidelines: '有且仅当用户明确要求以自己身份发消息、回复消息时使用' (use only when the user explicitly requests to send or reply to messages as themselves) and '当没有明确要求时优先使用message系统工具' (when not explicitly requested, prioritize using the message system tool). It also specifies security constraints requiring user confirmation before use, clearly defining when to use this tool 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?
No annotations are provided, so the description carries the full burden. It discloses key behavioral traits: the tool performs diagnostic checks on configuration and credential availability, specifically checking if a tenant access token can be obtained. However, it doesn't specify what the output looks like (e.g., success/failure status, error details) or any rate limits, leaving some behavioral aspects unclear.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Conciseness5/5
Is the description appropriately sized, front-loaded, and free of redundancy?
The description is a single, efficient sentence in Chinese that front-loads the key action ('诊断' meaning 'diagnose') and covers all essential aspects (what is checked and usage constraints) without any wasted words. Every part of the sentence earns its place.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Completeness4/5
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
Given the tool's complexity (simple diagnostic with no parameters) and lack of annotations/output schema, the description is mostly complete: it explains the purpose, usage context, and behavioral intent. However, it doesn't describe the return format (e.g., what diagnostic information is provided), which is a minor gap since there's no output schema to compensate.
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 appropriately states there are no parameters needed for this diagnostic check, which aligns with the empty input schema, adding no unnecessary parameter information.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Purpose5/5
Does the description clearly state what the tool does and how it differs from similar tools?
The description clearly states the tool's purpose with specific verbs ('检查' meaning 'check') and resources ('配置', '凭证可用性', 'tenant_access_token' meaning 'configuration', 'credential availability', 'tenant access token'). It explicitly distinguishes itself from sibling tools by focusing on diagnostic functionality rather than data operations like creating records or listing events.
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 guidelines by stating '不依赖具体权限' (does not depend on specific permissions), which clarifies when to use this tool (for configuration/credential checks without permission requirements) versus when to use sibling tools (which likely require specific permissions for operations like creating records or sending messages).
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 of behavioral disclosure and does so comprehensively. It describes the search scope ('跨会话'), filtering capabilities, pagination behavior, return format details (including specific fields like message_id, msg_type, content, sender, create_time, chat metadata), and how results relate to other tools. It also specifies important constraints like '所有参数均可选，但至少应提供一个过滤条件' (all parameters optional but at least one filter required) and page_size 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 well-structured with clear sections (purpose, usage, constraints, return values) and every sentence earns its place. It's appropriately sized for a complex 12-parameter search tool, providing necessary detail without redundancy. The information is front-loaded with the core purpose, followed by practical usage guidance, then technical constraints.
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?
For a complex search tool with 12 parameters and no annotations or output schema, the description provides complete context. It covers the tool's purpose, detailed usage scenarios, parameter constraints, return format (including specific field names and chat metadata), pagination behavior, and integration with sibling tools. The description fully compensates for the lack of structured metadata.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Parameters4/5
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
The schema has 100% description coverage, so the baseline is 3. The description adds significant value beyond the schema by explaining parameter relationships and constraints in the '【参数约束】' section, such as the requirement for at least one filter, mutual exclusivity between time filters, and page_size defaults/ranges. It also provides context about how parameters work together in the '用法' section. However, it doesn't fully explain complex parameter interactions beyond the basic 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 explicitly states the tool's purpose as '跨会话搜索飞书消息' (search Feishu messages across sessions) with the user identity context. It clearly distinguishes this search functionality from sibling tools like feishu_im_user_get_messages (which retrieves messages from a specific chat) and feishu_search_user (which searches for users). The verb '搜索' (search) combined with the resource '飞书消息' (Feishu messages) provides specific, unambiguous purpose.
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 in the '用法' section, detailing multiple filtering capabilities (keyword, sender, mentions, message type, time range, chat scope). It also specifies when to use this tool versus alternatives by stating that results can be used '配合 feishu_im_user_get_messages / feishu_im_user_get_thread_messages 查看上下文' (with those tools to view context). The parameter constraints section further clarifies usage rules like mutual exclusivity between time filters.
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:

[![lark-hermes-mcp MCP server](https://glama.ai/mcp/servers/WilliamMo101/lark-hermes-mcp/badges/card.svg)](https://glama.ai/mcp/servers/WilliamMo101/lark-hermes-mcp)

Score Badge

Copy to your README.md:

[![lark-hermes-mcp MCP server](https://glama.ai/mcp/servers/WilliamMo101/lark-hermes-mcp/badges/score.svg)](https://glama.ai/mcp/servers/WilliamMo101/lark-hermes-mcp)

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/WilliamMo101/lark-hermes-mcp'

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