agent4.io

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

With no annotations, the description must fully disclose behavior. It mentions the critical limitation of not reading local paths and provides alternative methods, but it does not describe what the tool actually does given that constraint, nor does it explain error handling, idempotency, or response format. Significant gaps remain.

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

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

The description is verbose with details about zip uploads and alternative endpoints that are not directly relevant to this tool. It could be restructured to focus on this tool's specific use case, with the alternatives as a brief note. The length is not justified by clarity.

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

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

Given the lack of schema descriptions and annotations, and the presence of an output schema, the description should provide a complete picture. It fails to clarify how the tool works with the 'path' parameter, what the output is, and when to use it. The description is incomplete for effective use.

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

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

The input schema has 0% description coverage, so the description must explain parameters. It does not describe any of the three parameters ('path', 'title', 'kb_name') explicitly. 'path' is mentioned but in a confusing way that contradicts the tool's stated purpose. This is a critical failure.

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

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

The description states 'add a local file into knowledge base (txt/md/html/pdf/docx)', which is a specific verb+resource. However, it immediately contradicts by saying the MCP runs on the server and cannot read local paths, making the actual purpose unclear. It does distinguish from sibling tool add_knowledge_text, but the ambiguity lowers clarity.

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

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

The description provides clear alternatives: for text files use add_knowledge_text, for binary files use console upload or curl, for folders use zip upload. It effectively tells when not to use this tool, but lacks an explicit statement of when this tool should be used, which prevents a perfect score.

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

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

The description discloses key behaviors: synchronous chunking and embedding, and return of a chunk count. With no annotations provided, this is adequate transparency, though additional details like permissions or error handling could improve it.

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

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

The description is two sentences, efficiently conveying purpose and alternative usage. No extraneous information, and the key points are front-loaded.

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

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

The description covers the main operation and return value but lacks parameter details. Given the output schema exists, the agent can infer return structure, but parameter semantics are missing, leaving gaps in completeness.

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

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

Schema coverage is 0% with no parameter descriptions. The description does not explain the meaning or formatting of 'title', 'content', or 'kb_name', requiring the agent to infer from context.

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

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

The description clearly states the tool adds a text document to the knowledge base, specifying it synchronously performs chunking and embedding and returns the chunk count. It also distinguishes itself from the sibling tool 'add_knowledge_file' by indicating that tool is for local files like PDFs.

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

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

The description explicitly directs users to use 'add_knowledge_file' for local files, providing an alternative for a different use case. This gives clear guidance on when to use this tool versus its sibling.

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

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

With no annotations, the description discloses key behaviors: new key, unpublished, does not grab default, no serial pointing. This provides transparency beyond the tool name, though it omits potential side effects or permissions needed.

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

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

The description is a single concise sentence that front-loads the action and lists key constraints in parentheses. It is efficient without wasted words.

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

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

Given the single parameter and the presence of an output schema, the description adequately covers the tool's purpose and behavioral constraints. It lacks details on prerequisites or return format, but these are partially addressed by schema.

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

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

Schema description coverage is 0%, meaning the description does not explain the parameter 'storyline_id'. Although the single parameter is self-explanatory, the description adds no additional semantic value, and coverage is low.

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

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

The description clearly states it copies a storyline as a new draft with specific properties (new key, unpublished, no default, no serial pointing). It uses a specific verb ('copy') and resource ('storyline'), and distinguishes it from siblings like 'create_storyline' and 'update_storyline'.

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

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

The description implies usage for creating a detached copy for modification but does not explicitly state when to use it versus alternatives like 'create_storyline' or 'export_storyline'. No when-not scenarios are mentioned.

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

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

No annotations are provided, and the description does not disclose behavioral traits such as permissions, immediacy of creation, or side effects. It only explains parameter semantics, leaving the agent's behavior during and after creation unclear.

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

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

The description is extremely concise: two sentences with a list-like structure. Every sentence adds value, and the main purpose is front-loaded. No wasted words.

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

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

Despite the presence of an output schema, the description lacks completeness for an 8-parameter creation tool. It does not explain the required name parameter, model, skills, published, or overall creation behavior, making it insufficient for confident use.

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

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

Schema coverage is 0%, and the description explains 4 out of 8 parameters (soul, task, tools, knowledge_bases) with meaningful notes. However, it omits details for name, model, skills, and published, so compensation is partial.

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

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

The description clearly states '新建 Agent' (Create new Agent), specifying the verb and resource. It also explains key parameters. However, it does not explicitly differentiate from sibling tools like update_agent, though the name implies creation.

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

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

The description provides some usage context for parameters, e.g., '先用 list_tools 看有哪些' for tools and '挂上后每轮自动检索注入' for knowledge bases. However, it does not compare with alternatives like update_agent or specify when not 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.

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

No annotations are provided, so the description carries full burden. It does not disclose behavioral traits such as idempotency, permissions, side effects, or response format. Only two parameters are explained, leaving the required 'name' and optional 'description' undocumented.

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

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

The description is concise, front-loading the purpose, and uses bullet-like formatting for parameter details. It is well-structured for a brief tool description.

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

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

Given an output schema exists, return values are not needed. However, the description omits prerequisites, required parameter guidance, and behavioral context, making it partially complete for a creation tool with no annotations.

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

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

Schema description coverage is 0%, but the description adds meaning for 'instructions' and 'max_distance' with specific usage context. However, the required 'name' parameter and optional 'description' are not explained, leaving gaps in parameter understanding.

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

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

The description starts with '新建知识库' (create knowledge base), clearly stating the verb and resource. It distinguishes from siblings like get, update, and add_* tools by focusing on creation.

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

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

The description implies when to use the optional parameters (instructions for model guidance, max_distance for relevance threshold) but does not explicitly state when to use this tool versus alternatives like add_knowledge_* or search_knowledge_base.

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

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

No annotations are provided. The description fails to disclose any behavioral traits such as safety (destructive vs. read-only), authentication needs, or side effects. For a creation tool, this is a critical gap.

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

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

The description is extremely short but not effectively concise. It front-loads the purpose but then switches to self-referential parameter advice. It lacks necessary substance for an agent to correctly invoke the tool.

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

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

Given the tool's complexity (4 parameters, 0% schema coverage, no annotations), the description is grossly inadequate. It does not explain the artifact being created, expected outcomes, or how it fits within the broader tool ecosystem.

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

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

Schema description coverage is 0%. The description offers meta-guidance on the 'description' and 'instructions' fields (e.g., 'description should be short' and 'instructions should be detailed'), but does not explain the functional meaning of 'name' or 'tools' parameters. This partially compensates for the schema gap but leaves two parameters unexplained.

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

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

The description states "新建技能" (create new skill), which is a basic restatement of the tool name. It does not differentiate this tool from siblings like create_agent or create_knowledge_base, and offers no specific verb or resource context beyond the name.

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

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

The description provides no guidance on when to use this tool versus alternatives. There is no mention of prerequisites, when-not-to-use, or exclusions, leaving the agent without decision-making context.

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

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

No annotations are provided, so the description takes full responsibility. It extensively details the graph structure, node types, exit kinds, and control flows (if/else, loops, AND-join). While it doesn't cover permissions or side effects, it gives thorough behavioral insight into how the storyline operates.

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

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

The description is very long and includes a full JSON schema for the graph object, which could be more concisely referenced. It front-loads the main purpose but becomes dense. The structure could be improved by separating core purpose from detailed reference.

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

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

Given the complexity (12 parameters, intricate graph structure, and existence of an output schema), the description is quite complete. It covers the graph definition, node types, exits, and common patterns. It provides enough detail for an AI agent to construct a valid storyline, though it lacks explicit parameter descriptions for all fields.

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

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

Schema description coverage is 0%, so the description must compensate. It explains graph, node, exit, profile_schema, and many other parameters indirectly. However, the required parameter 'agent_name' is not explained in the description, which is a significant omission. Some parameters like 'description' are mentioned but without explicit meaning.

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

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

The description clearly states '新建故事线草稿' (create a new storyline draft) and outlines the workflow of creating a draft, then validating with validate_storyline and publishing with publish_storyline. This differentiates it from sibling tools like validate_storyline and publish_storyline.

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

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

The description provides explicit steps: create draft, then validate, then publish. It explains conditions for is_default, allow_agent_enroll, and enroll_trigger, giving context on when to use these features. However, it does not explicitly state when not to use the tool or list all alternatives.

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

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

No annotations are provided, so the description carries full burden. It implies read-only behavior ('先读一遍'), but does not explicitly state no side effects, auth requirements, or rate limits. The return format is mentioned but not the response structure. Adequate but minimal transparency.

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

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

The description is extremely concise: three short sentences covering purpose, parameters, and usage workflow. Every sentence adds value. No redundant or filler content. Ideal length for a straightforward tool.

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

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

For a tool with 3 parameters and an output schema, the description covers purpose, key parameters, and typical usage. It integrates well with the sibling context (improve_prompt). However, the 'context' parameter is left undocumented, and there is no mention of the output schema details, though not required. Nearly complete but with one minor gap.

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

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

The description explains 'field' as same as improve_prompt and 'current' as the text to diagnose (required). This adds meaning beyond the schema for two of three parameters. However, the 'context' parameter is not explained at all, which is a gap. Schema coverage is 0%, so the description compensates well but not fully.

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

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

Clearly states it reads a field and returns specific improvement suggestions as a string array. Distinguishes from improve_prompt by explaining the workflow: diagnose first, then improve. The verb 'diagnose' and explanation of 'current' text make the purpose unambiguous.

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

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

Provides explicit typical usage: use diagnose_prompt to get suggestions, select those to adopt, then merge into improve_prompt's hint. This gives clear when-to-use and when-not-to (i.e., first diagnose, then improve) and differentiates from the sibling improve_prompt.

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

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

No annotations are provided, so the description carries full burden. It discloses that the exported JSON excludes tenant, version, and id, implying a sanitized output. However, it does not mention whether the operation is read-only, requires specific permissions, or has any side effects. Lacks detail on rate limits or asynchronous behavior.

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

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

Single sentence contains all necessary information: verb, resource, content details, and purpose. It is front-loaded and efficient, though slightly dense. No wasted words.

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

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

Given the tool's simplicity (one parameter, output schema exists), the description covers the main purpose and distinguishes the output from related tools. It could mention how the output is returned (e.g., file download or response body) but relies on output schema for that.

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

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

Only one parameter (storyline_id) exists with schema coverage 0%. The description does not explain the parameter's format, source, or constraints beyond its name. With low schema coverage, the description should compensate but does not add any parameter-level meaning.

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

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

Description clearly states the tool exports a portable storyline JSON with specific content (schema_version + definition, excluding tenant/version/id) for backup, migration, or re-import. It distinguishes from siblings like get_storyline and import_storyline by specifying the portable format and exclusion of certain fields.

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

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

Explicitly states use cases: backup, migration, or re-import. While it does not explicitly exclude scenarios or compare to siblings, the context of sibling tools (get_storyline, clone_storyline, import_storyline) provides implicit guidance. Could be improved by stating when not to use.

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

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

No annotations are provided, so the description carries the full burden. It correctly describes a read operation without side effects, but lacks details on authentication, permissions, or performance. The behavior is straightforward, but transparency is minimal.

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

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

The description is a single concise sentence in Chinese, front-loaded with the verb and resource. No redundant information; every word contributes to clarity.

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

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

The tool has an output schema, so the description need not detail return values. It lists key components of the configuration (soul, task, tools, skills, knowledge bases, model, parameters), which is sufficient for a 'get' operation. Completeness is high.

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

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

The single parameter 'name' is not described in the schema. The description compensates by implying it identifies an Agent, but does not specify format, origin, or valid values. For a single parameter, the added meaning is adequate but not rich.

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

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

The description clearly states it retrieves the full configuration of an Agent, including specific components like soul, task, tools, skills, knowledge bases, model, parameters. The verb '取' (get) and resource 'Agent' are specific, and it distinguishes from sibling 'get' tools for other entities.

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

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

The description implies usage when needing full agent configuration, but it does not explicitly state when to use this tool versus alternatives (e.g., list_agents for listing). No exclusions or context-sensitive guidance is provided.

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

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

With no annotations, the description fully carries the burden. It discloses what is returned (profile, spaces, console_url) and explicitly states what is not included (conversation content). This gives a good behavioral picture, though it could explicitly mark it as read-only.

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

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

The description is extremely concise: two sentences with clear front-loading of purpose, followed by negative clarification and extra detail. Every sentence adds value without redundancy.

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

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

Given the presence of an output schema and the tool's simplicity, the description covers most essential aspects: what is returned, what is not, and the console_url. The only gap is parameter semantics, which prevents a perfect score.

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

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

The schema has 0% description coverage for the sole parameter 'uid'. The description does not explain the format, source, or meaning of uid beyond the tool name context. This leaves the agent guessing, which is insufficient for a 1-parameter tool.

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

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

The description clearly states the verb 'get' and resource 'end_user details', specifying exact fields returned (basic profile and space list). It also distinguishes by clarifying what is not included (conversation content) and noting the console_url. This makes it distinct from list_end_users.

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

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

The description implies usage for retrieving details of a single end user, but does not explicitly contrast with list_end_users or state prerequisites (e.g., needing a uid). No when-not-to-use guidance is given, leaving some ambiguity.

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

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

No annotations are provided, so the description carries the full burden. It only mentions that the configuration includes the full instructions for the model, hinting at potentially large response size, but does not disclose read-only nature, error handling, or any side effects.

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

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

The description is a single sentence with no redundant words. Every part is informative and front-loaded with the main action.

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

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

Given that an output schema exists, the description need not detail return values. It covers the essential behavior of retrieving configuration including instructions. Missing details like existence of the knowledge base, but overall sufficient for a get operation.

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

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

Schema coverage is 0%, so the description should compensate. It adds minimal meaning by indicating the parameter is a knowledge base name (implied by '取某个知识库'), but does not describe format, uniqueness, or any validation rules.

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

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

The description clearly states the verb 'get' and the resource 'knowledge base configuration', and specifies it includes the full instructions for the model. This distinguishes it from siblings like 'list_knowledge_bases' (list all) and 'search_knowledge_base' (search).

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

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

The description implies usage for retrieving a specific knowledge base's configuration, but provides no explicit guidance on when to use it versus alternatives like 'list_knowledge_bases' or 'search_knowledge_base'. No when-not-to-use or exclusion criteria are given.

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

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

With no annotations provided, the description carries the full burden. It clearly states that the tool returns the complete content including instructions, which is a key behavioral detail about what the output contains.

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

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

The description is a single concise sentence that immediately conveys the tool's purpose without any unnecessary words or filler.

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

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

Given the presence of an output schema (not detailed here), the description provides sufficient context about what is returned (complete content plus instructions). It is complete enough for this simple retrieval tool.

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

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

With 0% schema description coverage, the description does not add meaning to the 'name' parameter beyond what the property name implies. However, the parameter is simple and self-explanatory.

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

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

The description clearly specifies the verb 'get' and the resource 'complete content of a skill (including instructions)', which effectively distinguishes it from sibling tools like list_skills (which only lists names) and create/update skills.

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

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

The description implies usage when full skill content is needed, but does not explicitly state when to use this tool versus alternatives like list_skills, nor does it provide any exclusions or prerequisites.

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

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

The description does not disclose behavioral traits such as read-only nature, authorization requirements, error handling (e.g., if storyline_id does not exist), or side effects. With no annotations, this information is missing.

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

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

The description is a single concise sentence that front-loads the core purpose. However, it lacks any structural elements like bullet points or separate sections for clarity.

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

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

Given the tool has one parameter and an output schema, the description adequately indicates the return contents but omits read-only implications or error conditions. It is minimally adequate.

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

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

The input schema has 0% description coverage, yet the description provides no additional meaning for the 'storyline_id' parameter beyond its type and requirement. Format, constraints, or examples are absent.

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

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

The description clearly states the tool retrieves the complete definition of a storyline, specifying it includes the graph, profile_schema, and top-level fields. This distinguishes it from sibling tools like clone_storyline or export_storyline.

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

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

No guidance is provided on when to use this tool versus alternatives such as get_agent or update_storyline. There is no mention of prerequisites, when not to use it, or context for usage.

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

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

With no annotations provided, the description carries the full burden of behavioral disclosure. It discloses that version numbers above system support are rejected, that new drafts are always created without taking defaults, that key conflicts auto-rename, and that override_agent_name can rebind to an existing agent. This provides good transparency about the tool's behavior beyond the basic import action.

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

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

The description is concise, with the main purpose stated in the first sentence. Subsequent sentences add important behavioral details in a logical order (versioning, creation behavior, parameter explanation). It is front-loaded and every sentence adds value, though the Chinese text could be slightly streamlined.

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

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

Given the tool has an output schema (not shown but indicated), two parameters, and nested objects, the description covers the key aspects: payload structure reference, versioning, conflict behavior, and agent override. It does not detail the return value, but the existence of an output schema likely covers that. The description is contextually complete for an import tool with clear expectations.

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

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

Despite 0% schema description coverage, the description adds significant meaning: it explains that 'payload' should be the return structure of export_storyline (including schema_version, graph, profile_schema, and top-level fields), which is essential for correct usage. It also explains the purpose of 'override_agent_name' as allowing rebinding to an existing agent. This compensates well for the lack of schema descriptions.

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

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

The description clearly states the tool's action: importing an exported storyline JSON to create a draft. It specifies the resource ('故事线' / storyline) and the verb ('导入' / import). It also distinguishes itself from siblings by referencing '读小说/资料生成故事线' as the typical use case, which sets it apart from export_storyline or create_storyline.

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

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

The description provides context on when to use this tool: for importing storylines generated from reading novels or materials. It mentions that version number awareness causes rejection if too high, and that new drafts are always created without overwriting defaults. It also explains the override_agent_name parameter for rebinding to an existing agent. However, it does not explicitly state when not to use it or list alternative tools.

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

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

No annotations provided, so description carries full burden. It explains the behavior: rewrites text based on field, returns only the improved text without explanation, and uses context for tailoring. It does not explicitly state that the operation is non-destructive or read-only, but the description implies it is a transform without side effects.

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

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

The description is moderately long due to the enumeration of field values and parameter explanations, but it is well-structured with front-loaded purpose and clear parameter descriptions. Every sentence adds value, though the inline field list could be replaced by a schema enum for brevity.

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

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

Given the tool's complexity (4 parameters, no annotations, but with output schema), the description comprehensively covers all aspects: overall purpose, parameter semantics, rewrite behavior, and return format. It fully compensates for missing schema descriptions and annotations, leaving no gaps for the agent.

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

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

Schema description coverage is 0%, but the description thoroughly explains each parameter: field's possible values and their effect, current's default behavior (draft from scratch), hint's purpose (direction), and context's role (specificity). This adds significant meaning beyond the schema's type and default annotations.

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

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

The description clearly states the tool rewrites text fields to be suitable as system prompts for AI, with specific verb 'rewrite', resource 'field text', and goal 'suitable as system prompt'. The list of field values and their rewriting goals further clarifies purpose and distinguishes from sibling 'diagnose_prompt'.

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

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

The description provides clear usage context: when you need to improve a prompt field. It explains how parameters like field, current, hint, and context should be used. However, it does not explicitly state when not to use this tool or mention alternatives like 'diagnose_prompt', which could be useful for diagnosis instead of improvement.

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

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

No annotations are provided, so the description carries full burden. It implies a read operation (listing) but does not explicitly state it is read-only, nor does it mention any behavioral traits like pagination, ordering, or rate limits. Basic operation is clear but lacks depth.

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

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

Single sentence with no unnecessary words. Front-loaded with clear purpose. Efficient and to the point.

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

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

For a zero-parameter list tool, the description sufficiently covers the return value (name and published status). Output schema exists but is not needed for basic understanding. Could mention ordering or lack of filtering, but not critical.

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

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

Schema has 0 parameters, so coverage is 100%. Description adds no parameter information, which is acceptable. Baseline of 3 applies.

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

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

The description clearly states it lists all agents in the tenant and specifies the returned fields (name and publish status). It is specific and distinguishable from sibling tools like get_agent (single agent) and create_agent.

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

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

No guidance on when to use this tool vs alternatives. There is no mention of using get_agent for details or any context about filtering. The description only states what it does without usage instructions.

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

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

With no annotations provided, the description bears full responsibility for behavioral disclosure. It details the returned fields, pagination via cursor, and the read-only nature. However, it does not address rate limits or authentication needs.

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

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

The description is concise with 4-5 sentences, uses formatting for emphasis, and front-loads the main purpose. It includes a typical example, making it efficient.

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

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

Given the presence of an output schema and the explanation of parameters, the description is fairly complete. It covers fields, filtering, sorting, pagination, and a use case, but lacks mention of default behavior or error conditions.

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

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

The schema has 0% parameter description coverage, so the description must compensate. It explains q (filter by name/external id), sort (recent or tokens24h), and cursor (pagination), but omits the limit parameter. Still adds significant value.

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

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

The description clearly states it lists end users of the tenant who chat with the agent, emphasizing it returns only the list, not conversation content. This distinguishes it from sibling list tools like list_agents.

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

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

The description provides explicit guidance on parameters (q, sort, cursor) and a typical use case (list_end_users(sort='tokens24h')). However, it does not explicitly state when not to use it or mention alternatives.

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

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

With no annotations, the description carries the full burden. It hints at return fields but does not disclose pagination, ordering, or limits. The information is adequate but not explicit about behavior beyond listing.

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

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

Single sentence, no waste, front-loaded with the essential purpose. Ideal conciseness.

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

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

For a zero-parameter list tool with an output schema present, the description is almost complete. It lacks mention of pagination, but given the simple nature and presence of an output schema, it is sufficient.

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

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

The input schema has zero parameters, so baseline is 4. The description adds no param info, but none is needed. The schema coverage is 100%.

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

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

The description clearly states the action (list), the resource (knowledge bases of this tenant), and specifies the included fields (document count, slice count, relevance lower limit). This is a specific verb+resource combination that distinguishes it from non-list tools.

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

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

No guidance is provided on when to use this tool vs. siblings like search_knowledge_base or get_knowledge_base. An agent would not know from this description which list-like tool to choose.

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

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

With no annotations, the description adds '只读' (read-only) and '不含密钥字段' (no key fields), which are valuable safety and content disclosure beyond the schema.

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

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

Single sentence, zero waste. Front-loaded with the purpose, followed by behavioral traits. Perfectly concise.

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

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

Given zero parameters and an output schema, the description provides all needed behavioral context (read-only, no secrets) for a simple list tool.

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

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

No parameters exist, so schema coverage is vacuously 100%. The description adds no param info, but none is needed. Baseline 4 is appropriate.

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

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

The description clearly states the verb '列出' (list) and the specific resource '本租户工具库里已接入的 MCP server', distinguishing it from sibling list tools for agents, skills, etc.

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

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

No explicit guidance on when to use vs alternatives. The resource specificity helps, but no exclusions or context cues.

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

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

No annotations are provided, so the description must carry the full burden. It states the tool lists all page action guides but does not disclose whether it is read-only, requires authentication, or has any side effects. For a straightforward list operation, this is minimally adequate but lacks explicit behavioral detail.

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

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

The description is a single sentence, concise and front-loaded with the main action. It includes parenthetical details for completeness without being verbose. Slightly more conciseness could be achieved, but overall it is well-structured.

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

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

Given the tool's simplicity (zero parameters, output schema exists), the description adequately covers what the tool does and its scope. It does not mention return format or ordering, but for a basic list operation, it is sufficiently complete.

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

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

The input schema has zero parameters, so the description correctly implies no filters by saying '全部' (all). This adds meaning beyond the empty schema. According to guidelines, zero parameters baseline is 4, and the description reinforces that no arguments are needed.

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

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

The description clearly specifies the verb 'list' and the resource 'page action guides' with scope 'this tenant'. It also details what is included (matching rules, opening remarks pattern, location), distinguishing it from sibling tools like page_context_stats or resolve_page_context.

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

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

The description does not provide explicit guidance on when to use this tool versus alternatives like page_context_stats or resolve_page_context. Usage is implied by the tool's nature as a list, but no exclusions or specific contexts are mentioned.

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

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

No annotations are provided, so the description carries the burden. It indicates a read-only operation but does not disclose potential limitations like pagination, scope, or implicit filtering.

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

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

The description is a single sentence with no unnecessary words, fully front-loaded, and efficient for the tool's simplicity.

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

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

Given the tool has no parameters and a clear purpose, the description is mostly complete. However, it could benefit from a brief note about the output (e.g., list of skill IDs and names).

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

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

No parameters exist, and schema coverage is 100%. The description adds no parameter details, but the baseline for 0-param tools is 4.

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

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

The description '列出本租户的技能' clearly states the action (list) and the resource (skills of the current tenant), distinguishing it from other tools like create_skill or get_skill.

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

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

No explicit guidance on when to use this tool versus alternatives (e.g., list_knowledge_bases, list_agents), nor any usage restrictions or assumptions.

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

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

No annotations are provided, so the description must disclose behavior. It mentions the output includes status, version, and default flag, which is helpful. However, it does not explicitly state that the operation is read-only and safe, which is implied but not guaranteed.

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

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

The description is concise, consisting of one sentence that includes all essential information without unnecessary words.

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

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

The description covers the key aspects: resource, scope, filter, and output fields. An output schema exists, so return values are detailed elsewhere. However, it lacks mention of pagination or ordering, which are common for list tools.

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

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

The schema description coverage is 0%. The description adds meaning by stating that the 'agent' parameter is for filtering, but it does not specify the format or behavior (e.g., exact match, partial match). For a single optional parameter, this is adequate but minimal.

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

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

The description clearly states the verb (list), resource (storylines), scope (tenant), and optional filtering by agent. It distinguishes from siblings like 'get_storyline' which retrieves a single storyline.

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

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

The description implies usage for listing storylines with optional filtering, but it does not provide explicit guidance on when to use this tool versus alternatives or when not to use it.

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

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

With no annotations, the description carries the burden. It states the tool lists information, which implies read-only behavior, but does not explicitly state safety, auth needs, or side effects. However, the straightforward nature of listing makes a 3 reasonable.

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

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

A single concise sentence effectively conveys the purpose with no waste. Every word earns its place.

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

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

Given zero parameters and an output schema, the description is complete: it explains the return value (list of tool names and descriptions) and the scope (assignable to agents). No additional context needed.

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

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

The tool has no parameters and schema coverage is 100%, so the description adds value by clarifying what is listed (assignable tools, including libraries/MCP). Baseline for zero params is 4.

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

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

The description clearly states it lists tool names and descriptions that can be assigned to agents, including from tool libraries and MCP tools. This is specific and distinguishes it from sibling tools like list_agents and list_mcp_servers.

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

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

The description implies usage for viewing assignable tools but does not explicitly contrast with other list tools or provide when-not-to-use guidance. Usage is implied but not detailed.

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

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

Discloses that only metadata is returned, includes console URLs, and mentions pagination via cursor. No annotations provided, so description must cover behavior, which it does adequately.

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

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

Description is moderately sized, front-loaded with key purpose (metadata only), and includes necessary details without excessive verbosity. Could be slightly more structured.

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

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

Covers output fields, pagination, and console URLs. With output schema existing, description adds value by explaining fields and usage. Does not address error handling or rate limits, but sufficient for the tool's complexity.

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

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

Schema coverage is 0%, and description does not explain parameters uid, limit, cursor individually. Only cursor is implied in pagination context. Lacks detail to fully compensate for missing schema descriptions.

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

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

Clearly states 'list user sessions' with metadata only, and explicitly says what is not returned (message content). Distinguishes from sibling tools like list_end_users.

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

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

Implies usage for retrieving session metadata and console URLs, and advises giving links to tenant for reading. Does not explicitly mention when not to use or compare with alternative tools.

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

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

No annotations are provided, so the description carries full burden. It indicates a read-only operation (stats retrieval) but does not disclose additional traits like caching, latency, or data freshness. The description is adequate but lacks extra context.

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

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

The description is a single sentence that front-loads the core data (opens and clicks) and purpose. Every word is necessary; no wasted text.

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

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

Given no parameters and an existing output schema, the description provides essential context about the return values (opens per guide and clicks). It is complete enough for a simple stats tool, though it could mention that it returns data per guide.

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

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

There are no parameters, so schema coverage is 100%. The description adds meaning by explaining the nature of the stats (opens and clicks), which is valuable beyond the empty schema. Baseline for zero parameters is 4.

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

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

The description clearly states the tool provides 'number of opens per guide and number of clicks on recommended questions' and its purpose is to find underperforming copy. It uses specific verbs and resources, distinguishing it from sibling tools like list_page_contexts or usage_stats.

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

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

The description implies when to use the tool (to find underperforming copy) but does not explicitly state when not to use it or mention alternatives such as usage_stats. The guidance is implicit rather than explicit.

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

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

With no annotations, the description fully discloses the behavioral pipeline: validation first, possible 422 error, then freezing and setting to published. This is comprehensive and transparent for a simple publish action.

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

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

A single sentence that efficiently captures the entire workflow: validation, error handling, and final state change. No redundant words or extraneous details.

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

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

Given the simple parameter and available output schema, the description covers the essential behavior and failure mode. It could mention idempotency or effects on already-published storylines, but overall it is adequate for the tool's complexity.

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

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

The schema has 0% description coverage, and the tool description does not add any explanation about the storyline_id parameter (e.g., format, meaning). The parameter is implied but not explicitly defined, failing to compensate for the schema gap.

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

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

The description clearly states the action ('publish storyline') and the resource, and distinguishes it from siblings by specifying the two-step process of validation then publication. It explicitly mentions the error condition (422 on blocking errors), setting it apart from validate_storyline or unpublish_storyline.

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

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

The description implies usage by describing the workflow: validate then publish. It does not explicitly state when not to use, but the context of sibling tools like validate_storyline and unpublish_storyline provides natural boundaries. Clear enough for an agent to decide.

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

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

With no annotations, the description carries the full burden. It implies the tool is read-only and safe, used for testing matching. However, it does not explicitly state side effects, authorization needs, rate limits, or that it is idempotent. The behavioral disclosure is adequate but not thorough.

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

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

The description is two sentences long and front-loads the main purpose. The second sentence adds valuable context about glob pitfalls, but is somewhat lengthy. Overall, it is concise and informative without unnecessary words.

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

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

Given the tool's simplicity (2 optional params) and the presence of an output schema, the description covers the core purpose and usage hint. However, it lacks detail on parameter formats, behavior when both params are provided, and what the output contains. The warning about globs is helpful but does not fully compensate for the missing parameter semantics.

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

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

Schema coverage is 0%, yet the description only mentions that the tool takes a URL or key without explaining what 'key' means or how the two parameters interact. Both are optional, but no guidance is given on when to use one versus the other, or if both can be provided simultaneously. The description adds marginal value beyond the parameter names.

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

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

The description clearly states the tool's purpose: given a URL or key, it resolves which guide/page context is matched. It also explicitly frames it as a validation step after writing matching rules, distinguishing it from sibling tools like upsert_page_context or list_page_contexts.

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

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

The description provides strong usage guidance by emphasizing that it should be used to verify glob matching rules after writing them. It warns about common pitfalls (missing *, extra path) and silent failures, which helps the agent decide when to invoke this tool. However, it does not explicitly mention alternatives or when not to use it.

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

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

No annotations are provided, so the description carries the full burden. It discloses that the tool returns 'top passages with title, layer, url and a snippet' and that content is public with no tenant data. This provides good behavioral insight, though it could mention if results are ranked or any API-specific behavior.

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

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

The description is three sentences long, front-loading the main action and purpose. Every sentence adds value: what it searches, when to use, and what it returns. No wasted words.

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

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

Given the tool's simplicity and the existence of an output schema, the description adequately covers purpose, usage, and return fields. The only shortfall is the lack of parameter explanations, which reduces completeness slightly.

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

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

Schema description coverage is 0%, so the description must compensate, but it does not explain any parameter details. The 'query' parameter is implied but not described as a search string, and 'k' (default 5) is not mentioned at all. The user must infer their meaning from context.

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

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

The description clearly states the tool searches 'agent4.io's own product docs' and distinguishes between 'concepts' and 'cookbook recipes'. This specifies the resource and scope, differentiating it from siblings like 'search_knowledge_base' which searches user knowledge bases.

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

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

The description explicitly advises using the tool when unsure about a feature, term, or how to build something. It mentions the content is public and involves no tenant data, providing clear context. However, it does not explicitly state when not to use it or compare directly with alternatives like 'search_knowledge_base'.

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

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

In the absence of annotations, the description reveals that the tool follows an identical retrieval path to real conversations, which is a key behavioral trait. It also explains the meaning of empty results. It does not cover auth or rate limits, but is sufficient for a read-only search tool.

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

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

The description is extremely concise: two sentences plus a short note. Every sentence adds value: the first gives the core action, the second and third provide usage guidance. No wasted words.

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

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

Given the tool's complexity as a search function with threshold testing, the description covers the key aspects: what it does, the retrieval path equivalence, and result interpretation. It does not need to detail return values since an output schema exists. Could mention result limits or ordering but is adequate.

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

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

The input schema has 0% description coverage. The tool description implicitly ties kb_name to the knowledge base and query to the search text, but does not elaborate on formats, constraints, or provide any additional semantic value beyond the parameter names.

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

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

The description clearly states the tool searches a knowledge base and returns matching fragments and distances. It distinguishes itself from sibling tools like list_knowledge_bases or get_knowledge_base by focusing on retrieval.

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

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

The description explicitly explains the tool uses the same retrieval path as real conversations and advises using it to verify thresholds and slices. It interprets empty results as 'not covered'. However, it does not specify when not to use it or mention alternatives.

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

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

No annotations are provided, so the description bears full responsibility for behavioral disclosure. It only mentions the output content but does not state that it is a read-only operation, has no side effects, or any potential rate limits. Minimal transparency.

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

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

The description is a single short sentence, making it concise. However, it could be more informative without significant length increase. It earns its place but lacks structure.

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

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

Given there are no parameters and an output schema exists, the description is somewhat complete. It explains the return type. However, it misses context like authentication or read-only nature. Adequate for a simple info tool.

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

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

There are no parameters, so schema coverage is 100%. The description adds meaning beyond the empty schema by specifying what the tool returns (basic info and quota). It could be more detailed but is adequate.

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

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

The description clearly states that the tool returns 'basic information and quota of this tenant.' While it lacks a verb like 'get' or 'retrieve,' the noun phrase implies a read operation. It is distinct from sibling tools, which are mostly CRUD operations.

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

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

No guidance on when to use this tool versus alternatives. Although no sibling does exactly the same thing, the description does not specify context or prerequisites.

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

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

With no annotations, the description fully discloses key behavioral traits: the storyline is archived, users in transit are silently downgraded, progress is saved, and republishing resumes it. This covers the major side effects, though it omits permission requirements or error scenarios.

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

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

The description is extremely concise: a single sentence that first states the action and then lists key consequences. Every part adds value, with no redundant phrases. It is well-front-loaded and efficiently packaged.

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

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

Given the tool's simplicity (1 parameter, output schema exists), the description covers the main operation and its effects on users and progress. It mentions reversibility via republish. Minor gaps include not clarifying if the operation is idempotent or what happens to non-in-transit users, but overall it is sufficiently complete for an archive action.

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

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

The input schema has 0% description coverage, and the tool description does not mention the 'storyline_id' parameter at all. While the parameter name is self-explanatory, the description should explicitly state that the ID of the storyline to unpublish is required. It adds no semantic value beyond the schema.

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

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

The description clearly states the tool's purpose: to deactivate/archive a storyline. It explains the effects (no auto-connect, user downgrade, progress retention) and distinguishes from the sibling 'publish_storyline' by being its inverse. The verb '下线（归档）' and the explanation leave no ambiguity.

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

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

The description implicitly signals when to use (to archive a storyline) but does not explicitly state conditions or provide guidance on when not to use. It lacks comparison with alternatives or exclusions, leaving the agent to infer usage context from the behavior description.

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

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

With no annotations, the description carries the full burden. It clearly explains the PATCH behavior (fields not passed remain unchanged) and contrasts with the old full-replacement approach. However, it does not address whether explicit null values set fields to null or are ignored.

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

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

The description is concise overall, with two sentences plus historical context. The key point (partial update) is front-loaded. The historical anecdote adds value but could be more succinct.

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

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

Given 13 parameters and 0% schema coverage, the description explains the core behavior but omits details like output format (though output schema exists) and ambiguity around null values. It is adequate for a simple partial update tool.

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

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

Schema description coverage is 0%, and the description does not elaborate on individual parameters (only mentions 'partielle felder'). The agent must rely solely on parameter names, which may be insufficient for correct usage.

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

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

The description clearly states '改 Agent 的**部分**字段' (update partial fields of Agent), specifying the verb and resource. It distinguishes from sibling tools like create_agent and get_agent.

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

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

The description explains that previously a GET-merge-PUT workflow was needed, but now this tool uses PATCH semantics for partial updates. It implicitly guides when to use this tool (when updating only specific fields) and provides context.

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

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

With no annotations, the description carries the full burden. It reveals the read-modify-write pattern but omits permissions, side effects, or error behavior. This provides moderate transparency.

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

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

The description is extremely concise with one sentence, but it lacks structure and important details. It is efficient but at the expense of completeness.

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

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

Given the 4 parameters and existing output schema, the description is insufficient. It does not explain return values, parameter constraints, or steps needed for successful use, leaving gaps.

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

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

Schema description coverage is 0%, so the description must compensate, but it adds no detail about parameters like max_distance or instructions. Only the generic 'modify some fields' is given.

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

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

The description states the tool modifies fields of a knowledge base, which is a specific verb and resource. It compares to update_agent, distinguishing it among sibling tools. However, it does not explicitly list which fields are modifiable.

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

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

The description mentions a 'first GET then merge' pattern, implying partial updates, which gives some guidance. But it does not specify when to use this vs alternatives like create_knowledge_base or update_agent.

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

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

Given no annotations, the description discloses the critical merge behavior (GET then merge) to prevent data loss from full replacement, which is essential for the agent to avoid unintended overwrites.

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

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

The description is a single, concise sentence that covers the tool's purpose and key behavioral trait without unnecessary words.

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

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

The description covers the core behavior (partial merge update) and references the sibling tool for similarity. With an output schema present, the return format is covered. However, it doesn't explicitly state that the 'name' parameter is the identifier for the skill to update, which is a minor gap.

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

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

The schema has no property descriptions (0% coverage), so the tool description should explain parameter roles. It only says 'modify some fields' without listing or explaining which fields are modifiable or their semantics, leaving the agent to infer from parameter names.

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

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

The description clearly states the tool modifies fields of a skill, references update_agent for similarity, and explains the 'get then merge' strategy to avoid overwriting unpassed fields, which distinguishes it from a full replacement update.

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

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

The description references update_agent as a similar tool and explains the merge behavior, providing context for when this tool is appropriate (partial updates). However, it does not explicitly state when not to use it or list alternatives.

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

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

No annotations are present, so the description carries full responsibility. It states PUT semantics and optimistic locking, indicating full replacement and version checks. However, it does not disclose idempotency, error behavior on version mismatch, or that all fields must be provided for full replacement. Some ambiguity remains.

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

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

The description is very concise—two short sentences that front-load the core purpose (PUT replacement) and key additional details (optimistic locking, structure reference). Every sentence adds value, though the Chinese language might limit accessibility for some agents.

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

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

Despite having an output schema, the description fails to explain the return value or the full set of parameters. It does not cover required fields, default behaviors, or consequences of omitting optional fields. For a complex tool with 14 params and no schema descriptions, this is insufficient.

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

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

With 14 parameters and 0% schema description coverage, the description only adds meaning for 'expected_version' (optimistic locking) and implicitly for 'graph' (by referencing create_storyline). The remaining 12 parameters (e.g., name, description, is_default) are not explained, forcing the agent to rely on parameter names alone.

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

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

The description explicitly states '整体替换一条故事线草稿（PUT 语义）', clearly indicating a full replacement operation (PUT) on a storyline draft. It distinguishes from siblings like create_storyline (create) and clone_storyline (clone) by specifying the update action.

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

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

The description mentions optimistic locking via expected_version and references create_storyline for structure details, implying this tool is for updating existing storylines. However, it does not explicitly state when to use this vs alternatives (e.g., create, clone, import), though it's reasonably inferred.

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

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

With no annotations, the description discloses key behavioral traits: whole-replacement semantics (fields fall to defaults), url_pattern matching logic, and greeting_mode behavior. Could mention permissions but covers major risks.

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

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

Five concise sentences with front-loaded purpose. The warning about replacement is well-placed. Could be slightly more structured but efficient overall.

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

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

Given 9 parameters, no annotations, and output schema existence, the description covers main behavioral and parameter aspects but misses some parameter meanings (position, is_default). Adequate for basic use but not fully complete.

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

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

Schema coverage is 0%, so description compensates by explaining context, url_pattern, greeting_mode, and partly greeting/questions. However, label, position, and is_default lack clarification.

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

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

The description clearly states the tool's verb ('新建或整条替换') and resource ('页面行动指南'). It distinguishes from siblings like list_page_contexts and resolve_page_context by emphasizing the upsert/replace behavior.

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

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

Explicitly advises when to use this tool vs list_page_contexts for partial updates, and explains the resolution priority for key, url_pattern, and default. Provides strong context for selection.

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

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

No annotations are provided, so the description fully bears the burden. It explicitly states the tool returns only metadata and no conversation content, implying it's a safe, read-only operation. However, it doesn't explicitly declare read-only or mention rate limits or permissions.

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

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

Three sentences, each serving a distinct purpose: tool definition, content clarification, and usage examples. No redundant words. Highly efficient for its length.

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

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

An output schema exists, so return values need not be detailed in the description. The description gives enough context (metadata, no content, grouping options). It could be more complete by mentioning if stats are aggregated or per-record, but overall sufficient.

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

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

Schema coverage is 0% with no parameter descriptions, but the description compensates by listing the allowed values for the 'group' parameter (total, agent, user, space, day, model) and providing usage examples. This adds essential meaning beyond the schema.

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

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

The description clearly states it provides usage statistics (token counts, event counts) and specifies that it returns only metadata, not conversation content. It lists possible group values and gives usage examples. However, it doesn't explicitly differentiate from sibling tools like page_context_stats.

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

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

The description provides guidance on when to use specific group values (e.g., group='user' to see top users). But it lacks any comparison to sibling tools or advice on when not to use this tool, leaving the agent without explicit selection criteria.

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

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

No annotations provided, so description carries full burden. It discloses the validation checks performed (entry, dead end, etc.) and that it returns ok/errors, implying no side effects. It could mention if it's read-only or time-consuming, but the validation nature is clear.

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

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

The description is one sentence with a clear purpose, list of checks, and return format. No wasted words; important information is front-loaded.

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

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

Given the tool has one parameter and an output schema, the description covers the core functionality and return shape. It could explain the error structure more, but output schema likely provides details. Adequate for a validation tool.

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

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

Schema coverage is 0% and description does not elaborate on the storyline_id parameter beyond its name. The description validates the storyline graph but doesn't explain the ID format or source. Little added meaning beyond the schema.

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

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

The description clearly states the tool validates a storyline graph, listing specific checks (entry, dead end, unreachable, etc.) and return format {ok, errors}. It differentiates from sibling tools like publish_storyline or create_storyline by its validation purpose.

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

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

The description explicitly says '必须 before publishing' (must pass before publishing), indicating when to use. It does not mention alternatives or exclusions, but the context from sibling tools implies it's a prerequisite for publish_storyline.

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