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 explicitly explains damage mechanics (temp HP absorbs first, clamps to 0), healing cap (max), side effect (status=down when HP reaches 0), and return value (new hp + status). This is thorough and transparent about the tool's behavior.

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

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

The description is two sentences with no fluff. It front-loads the purpose, then explains the delta rules and side effects, then states the return value. Every sentence earns its place, and it is concise without being under-specified.

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

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

For a simple mutation tool with no annotations and no output schema, the description covers the essential information: what it does, the mechanics of delta, the side effect of reaching zero, and the return value. It does not mention error handling or prerequisites (e.g., combatant must exist in encounter), but these are not critical for calling the tool correctly. It is complete enough for an agent to use it without further information.

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 the delta parameter well (negative for damage, positive for healing, temp HP logic, max cap). Campaign, encounter, and combatant_id are self-evident from their names and context, but the variant parameter (with default 'main') is not explained at all. The description adds value for delta but leaves variant 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?

Description clearly states the tool modifies a combatant's HP with a delta, specifying damage vs healing behavior. It is specific about the resource (HP) and the action (apply change), but does not explicitly differentiate from siblings like resolve_attack or roll_damage, which also affect HP indirectly. Purpose is clear and 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?

No guidance on when to use this tool versus alternatives. It does not mention that this is a direct HP modification tool as opposed to attack resolution or damage rolling. The only implied usage is from the description's mechanics, but there is no explicit when-to-use or when-not-to-use guidance.

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

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

With no annotations, the description must disclose behavioral traits. It does mention that id/type/name are auto-written and that overwrite=True replaces same-named notes. However, it does not specify what happens on conflict when overwrite=False (error vs. skip), nor any permissions or side effects. The safety profile is unaddressed, leaving meaningful gaps.

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 compact three-sentence paragraph. It front-loads the core purpose and packs note_type enumeration and overwrite semantics into a small space. It is efficient with no fluff, though a slight reorganization could improve scannability.

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 six parameters, no output schema, and no annotations, the description is moderately complete. It covers creation basics and the overwrite scenario, but omits return values, error handling, and the structure of the note object. For a tool of this complexity, more behavioral and output detail would be expected.

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 must compensate for all six parameters. It explicitly explains note_type (with a full list), campaign (when required), and overwrite (behavior). But it leaves name, body, and frontmatter vague: name is required yet the description says id/type/name are auto-written, which is confusing; body is only implied by '正文'; frontmatter is never described. The description adds value for three parameters but not the others.

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 creates a vault note with YAML frontmatter and body, and enumerates the valid note_type values. This is a specific verb (create) on a specific resource (vault note), distinguishing it from sibling tools like read_note and list_notes. The inclusion of the note_type list adds precision.

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

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

It gives contextual guidance for parameters (campaign-scoped types require campaign) and explains the overwrite flag's purpose (idempotent reruns for module parsing). However, it does not explicitly contrast with alternatives like read_note or list_notes, nor state when to choose this tool over an update. The usage context is implied but not fully 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?

没有提供注释，因此描述需要承担行为透明度的负担。描述说明了它接受字符串形式的CR值（如'1/4'、'5'），但未说明返回格式、错误处理或是否处理所有CR范围。对于纯计算工具，没有副作用或权限要求，但缺乏细节限制了行为透明度。

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?

描述非常简洁，仅一句话，信息量饱满，直接以功能起始并给出参数示例。没有冗长内容，每个词语都承载信息，符合前端加载原则。

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?

该工具非常简单，仅有一个参数且无输出 schema。描述提供了转换功能和参数格式，但未说明返回值的具体形式（如数值、单位）或潜在限制（如是否包含整数CR的全部列表）。对于简单工具，描述可用但并未完全覆盖 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 描述覆盖率为0%，而描述明确说明了参数'cr'的语义，指出它接受字符串形式的挑战等级（如'1/4'、'5'），并暗示了可接受的格式。这显著超越了原始 schema，有助于 agent 正确构造输入。

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?

描述明确说明了功能：将挑战等级（CR）转换为经验值（XP），并给出了示例输入（'1/4'、'5'），这表明了具体动词（转换）和资源（CR到XP）。它与其他兄弟工具（如encounter_budget、monsters_by_cr）有明显区分，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?

描述隐含了使用场景（需要将CR转为经验值时），但没有提供何时不使用此工具的排除条件或替代方案。没有提到与相关工具（如encounter_budget）的区别，但考虑到功能简单，基本上下文是清晰的。

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 behavioral burden and does say this is a calculation under the 2014 rules. However, it does not explicitly state that the tool is read-only, that it does not modify encounter state, or what form the returned budget takes.

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 clean sentence with no filler, includes the relevant edition qualifier, and puts the action and inputs in the same clause. Every word contributes to the tool's core meaning.

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 no output schema, no parameter documentation, and no annotations, this description is too thin. It omits the allowed difficulty values, the input-level constraints, and what a usable budget response actually contains, making correct invocation harder than it needs be.

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 is responsible for explaining the inputs. It references party_levels and difficulty only broadly; it does not list valid difficulty strings, how levels are interpreted, or how the default 'medium' relates to behavior.

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

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

The description names a concrete verb and resource: calculate an XP budget for a given difficulty from party levels, and it adds the scoping detail that it is the 2014-rules version. This distinguishes it from sibling tools like evaluate_encounter or cr_to_xp, which either evaluate an existing encounter or convert CR to XP.

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 phrasing implies use when the agent has the party levels and a difficulty and needs a budget XP, but it gives no explicit conditions, exclusions, or alternative-tool routing. An agent must infer that start_encounter or evaluate_encounter is not the right tool here.

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 behavioral disclosure burden. It adds useful context by specifying the 2014 rule variant and that the evaluation includes encounter multiplier and party-size offset. However, it does not disclose what the returned result looks like, edge cases, 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 dense sentence that front-loads the core purpose and key algorithm detail. It is concise and free of filler, though it could benefit from a second sentence covering return behavior or usage examples.

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 calculation tool with no output schema and no annotations, the description is incomplete. It tells the agent the general formula components and the monsters shape, but omits what the output contains, how party_levels influence the result, and any limitations or edge cases. An agent would still need to infer or experiment to understand the full behavior.

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

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

Schema description coverage is 0%, so the description must compensate. It does provide a concrete format for the monsters parameter ('cr'|'xp', 'count'), which is valuable. However, it does not clarify party_levels or ruleset semantics beyond what the parameter names and default value imply, leaving partial coverage.

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 evaluates encounter difficulty using 2014 rules, including encounter multipliers and party-size offset. This is a specific verb + resource and conveys meaningful differentiation from generic tools, though it does not explicitly name sibling tools like encounter_budget.

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?

There is no guidance on when to use this tool versus alternatives. The description implies use for evaluating encounter difficulty under the 2014 ruleset, but it does not state exclusions, prerequisites, or when a sibling tool such as encounter_budget would be more appropriate.

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 behavioral burden. It clearly says the operation is an append (追加进向量库), notes an auth/prerequisite need (OpenAI key), and declares a return value ({count}). It does not discuss deduplication or overwrite behavior, but the core side-effect is transparent enough.

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 tight and front-loaded: it opens with the action, then gives metadata, usage context, prerequisite, and return value in two compact sentences. No words are wasted.

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 six parameters, no annotations, and no output schema, the description provides the general workflow but leaves gaps: ruleset is unnamed, the semantic of the returned count is ambiguous, and there is no explanation of what constitutes a chunk. It is adequate but not enough to fully handle all invocation nuances.

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 no descriptions (0% coverage), and the description partially compensates by listing the metadata group 'campaign/source/license/note_id' and implying text is the prose to index. However, the ruleset parameter is entirely omitted and the precise value semantics of each metadata field are not explained, so it only modestly bridges the coverage 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: '把一段模组散文切块嵌入并追加进向量库' (chunk module prose and append into the vector DB) and gives the purpose of making content retrievable via semantic_search by campaign. This is specific enough to distinguish from sibling tools like semantic_search and create_note.

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

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

The description gives clear context for when to use the tool—when you want indexed module prose to be semantically searched—and names a prerequisite (OpenAI key). However, it does not explicitly compare against alternatives or say when not to use it, so it misses the 'when-not' layer.

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 the return shape ({notes:[{path,name,type}]}) and mentions filtering, which is useful. Since no annotations are provided, the description carries the full burden, but it does not explicitly state the operation is read-only or address side effects, sorting, or pagination. 'List' implies no mutation, so this 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 a single, well-structured sentence that front-loads the action, then the filters, then the return format. Every phrase earns its place, with no redundant or vague wording.

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

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

For a simple list tool with two optional filters, the description covers the essentials: what it lists, how to filter, and what it returns. It omits optional details like ordering and pagination, but these are not critical for the tool's basic usage.

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, so the description must compensate. It names both parameters (note_type, campaign) and indicates they are filters, adding meaning beyond the bare property names. However, it does not specify value formats, matching semantics, or constraints, 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 uses the specific verb '列出' (list) with a clear resource, 'vault 笔记', and names the optional filters (note_type / campaign). This makes the tool's purpose unambiguous and distinguishes it from sibling tools like create_note, read_note, and semantic_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 provides clear context: it lists notes and supports filtering. However, it does not explicitly state when to use an alternative such as read_note or semantic_search, though the 'list' action is self-explanatory enough.

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 discloses what is loaded and the return shape, including state.md, style profile, and active encounters. However, it does not state whether loading has side effects, what happens for missing campaigns, or whether it creates or updates any files.

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

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

The description is compact, front-loaded with the main purpose, and includes the return object in a single line. Every sentence adds useful information with no filler or repetition.

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 tool's purpose, return shape, and usage context well for a simple loader. However, it omits parameter semantics and behavioral details such as failure modes or side effects, leaving some gaps that an AI agent would need to infer.

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 explain the meaning of 'campaign' or 'variant' as parameters. It mentions them only in the return object, which provides minimal indirect context but does not compensate for the complete lack of parameter documentation.

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 a specific verb ('载入' / load) and resource ('战役实例' / campaign instance), listing the loaded components and the return object. It distinguishes this from siblings like load_style by emphasizing a one-time full-context load, though it does not explicitly name any sibling or contrast itself with them.

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

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

The description gives clear use context: '开局/续团' (starting or continuing a session) and 'solo-dm 带团入口' (entry point for solo-DM sessions). It implies when to call this tool but does not state exclusions or alternative tools explicitly.

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 behavioral burden. It discloses an important fallback behavior ('if missing, returns a neutral default') and the exact return shape {campaign, found, frontmatter, body}. It does not state side-effect read-only status or error behavior, but 'load' plus the fallback statement is sufficiently transparent.

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 earning its place: one defines the resource and fallback, one states when to use it, and one gives the return contract. There is no redundant or filler wording.

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

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

For a simple one-parameter, read-oriented tool, the description covers purpose, usage timing, missing-data behavior, and the return shape. It does not explain the semantics of frontmatter/body, but that is inferable from the contents described in the first sentence.

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 must compensate for the single 'campaign' parameter. It clarifies that the parameter identifies the campaign whose style profile is loaded, but it does not provide format, allowed values, or identifier semantics. For a single obvious parameter this is minimally 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 names a specific verb ('loads'), a specific resource (a campaign's style profile), and enumerates what that profile contains (system prompt fragments, tone examples, taboos). This clearly differentiates it from siblings like load_play_context by focusing on stylistic tone rather than broader 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?

It gives an explicit timing instruction: call before preparation, analysis, or running to align output with the campaign's tone. It does not explicitly mention exclusions or alternative tools, so it stops short of a 5.

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?

There are no annotations, so the description carries the behavioral disclosure burden. It does disclose the lookup behavior and the return shape (data + Chinese name + source citation), which is useful. It does not disclose match semantics (exact vs fuzzy, first vs all matches), no-match behavior, or error conditions, so transparency is adequate but not rich.

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, front-loaded sentence with no filler. It places the action and query criterion first, then the return contents. Every word contributes to selection or invocation.

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 one-parameter, read-only lookup with no output schema, the description is nearly complete: it tells the agent what to pass and what to expect back. The main gaps are ambiguous no-match behavior and the vague '数据' (data) portion of the return, which could matter if downstream steps depend on knowing exact result 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?

The schema only describes 'query' as a string with no property description (0% coverage). The description compensates by defining what the query can be: a Chinese name, English name, or slug. This is essential semantic information for invoking the tool correctly, though it stops short of giving concrete examples or formatting constraints.

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

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

The description names a specific verb ('查' / lookup), a specific resource ('SRD 状态' / condition), and the accepted input forms (Chinese/English name or slug). It also states the return contents (data + Chinese name + source citation), which clearly distinguishes it from sibling tools like lookup_monster, lookup_spell, lookup_rule, and translate_term.

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 this tool: whenever an agent needs an SRD condition/status by name or slug. However, it does not explicitly state when to prefer this over related siblings (e.g., lookup_rule or translate_term), nor does it offer any exclusions or 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 the full burden of behavioral disclosure. It states the tool returns data, Chinese name, and source citation, which is useful. However, it doesn't disclose whether the lookup is exact-match only, case-sensitive, whether partial matches are allowed, what happens on no match, or any rate limits. For a read-only lookup tool, this is a moderate 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?

One sentence, front-loaded with the action and resource, and includes the key return values. Every word earns its place. No fluff or repetition.

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

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

For a simple single-parameter lookup tool, the description covers the core purpose and return values. However, with no output schema and no annotations, it doesn't specify the exact structure of the returned data, error behavior, or matching rules. It's adequate for a basic lookup but leaves some operational details unspecified.

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 only says the query can be a Chinese/English name or slug. It doesn't explain the expected format (e.g., should the slug be URL-encoded, are spaces trimmed, is it case-insensitive). The single parameter 'query' is minimally documented in the schema, and the description adds only the type of value, not the semantics of matching behavior.

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

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

The description states a specific verb ('查' = look up) and resource ('SRD 怪物' = SRD monsters), and specifies the query types (Chinese/English name or slug). It distinguishes itself from sibling tools like lookup_spell, lookup_condition, and lookup_rule by naming the resource type. However, it doesn't explicitly contrast with those siblings, so it's clear but not fully differentiated.

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 this tool: when you need SRD monster data by name or slug. It doesn't explicitly state when not to use it or mention alternatives like monsters_by_cr or semantic_search, which could also be used to find monsters. The context is clear enough for a simple lookup, but no exclusions or alternative routing 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?

No annotations are provided, so the description carries the behavioral burden. It explicitly discloses the most important behavior: a miss returns found=false and it never fabricates results ('绝不编造'), which is a major hallucination guard. It does not mention side effects (though a search tool likely has none), rate limits, or return structure, but the no-fabrication disclosure is significant and valuable.

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 compact sentence that front-loads the core action and then adds the crucial behavioral guarantee. There is no wasted wording, and the most important behavioral note (no fabrication) is included without bloating the 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?

The description leaves an important gap: it details the miss behavior (found=false) but does not describe what a successful hit returns. With no output schema or annotations, the agent does not know whether the raw rule text, metadata, or other fields comprise the result. For a simple tool with one input, the missing success-response details make it somewhat incomplete.

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 for the query parameter. It adds that query is a '关键词' (keyword), which is meaningful semantics beyond the generic 'Query' label. However, it does not provide examples, syntax, or constraints on the keyword type, so it only partially compensates 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 states the specific verb '关键词检索' (keyword search) and the resource 'SRD 规则条目' (SRD rule entries), which distinguishes it from sibling lookup tools such as lookup_monster, lookup_spell, and lookup_condition. This is a clear, resource-specific purpose that an agent can immediately understand and differentiate.

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: when you need to do a keyword search against SRD rule entries. It is clear enough that an agent would use it over monster/spell/condition lookups, but it does not explicitly mention alternative or say when not to use it, such as preferring semantic_search for fuzzy queries.

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 of behavioral disclosure. It conveys the accepted input forms (Chinese/English name, slug) and what is returned (data, Chinese name, source), which is useful. However, it does not disclose the no-match behavior, matching semantics (exact vs. fuzzy, partial names), or response shape, and the read-only nature is only implied by the verb 查.

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 well-structured sentence leads with the query contract and follows with the return payload. Every chunk adds value — the resource, the two accepted query forms, and the three return components. No filler or repetition.

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 one-parameter tool with no output schema and no annotations, the description covers the purpose and the accepted query form, but the returned '数据' remains underspecified — the agent cannot know the shape or the detail level of the returned spell entry. No-match behavior is also unspecified, so the agent has limited understanding of edge cases.

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 is nearly bare — the single required 'query' is just a string with 0% coverage. The description compensates by defining what the query accepts: a spell name in Chinese or English, or a slug. This is essential semantic content that the schema alone lacks. It does not specify normalization or case handling, so marginally short of a 5.

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

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

The description states a specific verb (查/look up), a concrete resource (SRD 法术/spells), and the query surface (name in Chinese or English, or slug). It also enumerates the returned payload (data, Chinese name, source citation). This functionally distinguishes it from sibling lookups like lookup_monster, lookup_condition, and lookup_rule, even without naming them explicitly.

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

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

Usage context is only implied: an agent can infer this tool is for fetching spell data when it has a name or slug. There is no explicit statement about when to prefer it over related spell tools (spell_save_dc, spell_attack_bonus) and no exclusions or failure scenarios (e.g., no match). Guidance is adequate but strictly implicit.

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

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

With no annotations, the description carries the behavioral disclosure burden. It explains the advance_turn out-of-bounds behavior (round+1 and reset to zero), the set/clear conditions operation, spell slot updates, and the return shape. This is strong transparent context for a state-mutating tool, though it does not discuss side effects or validation.

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

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

The description is compact and front-loads the main operations, with the return shape appended for completeness. The slash-separated style is efficient, though slightly terse and potentially ambiguous in the middle segment.

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 an 8-parameter tool with no annotations and no output schema, the description covers key behaviors and return values but omits contextual details: there are no examples, no guidance on which parameter combinations are valid, and no statement about destructive effects. It is adequate for basic calls but incomplete for confident autonomous invocation.

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 does explain the semantics of advance_turn, set_conditions, clear_conditions, spell_slots, and implies combatant_id. However, it leaves campaign, encounter, and variant unexplained, and does not clarify how set_conditions and clear_conditions interact or whether operations can be combined.

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 names the tool's specific actions: advancing the initiative cursor, managing combatant conditions, and setting spell slots. It is more specific than the broad name 'manage_combat_state' and distinguishable from siblings like start_encounter or update_campaign_state, though it does not explicitly name an alternative.

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 operations imply usage: an agent would use this when advancing initiative, changing conditions, or updating spell slots during combat. However, there is no explicit when-to-use guidance or exclusion, such as 'use update_campaign_state for non-combat state changes', so the agent must infer the boundary between this and sibling tools.

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

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

With no annotations, the description carries the full burden and does a good job: it discloses input format ('1/4', '5'), the range semantics (min..max), and the exact return shape ({count, monsters:[{index,name_en,name_zh,cr}], citation}). It does not mention edge cases, pagination, or error behavior, which would improve transparency, but the core behavior is well communicated.

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

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

Two tightly written sentences pack purpose, input format, and return shape with no filler. The primary purpose is front-loaded, and every sentence earns its place. There is no redundancy with the schema.

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 list tool with no annotations or output schema, the description covers the essential contract: purpose, parameter meaning, accepted values, and return structure. Minor gaps include lack of explicit mention of null max_cr behavior and potential errors, but these are not critical for invocation. Overall it is nearly complete.

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

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

Schema description coverage is 0%, so the description must compensate. It does by explaining that min_cr and max_cr form a CR range and by giving concrete value examples ('1/4', '5'). It doesn't explicitly state that max_cr defaults to null, but the schema already provides that default. This adds meaning beyond the bare 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 uses a specific verb ('列出' / list) and resource ('SRD 怪物' / SRD monsters), and defines the scope by CR or CR range. It also states the intended use case ('供按遭遇预算选合法怪物'), which distinguishes it from sibling tools like lookup_monster (single monster lookup) and cr_to_xp (conversion to XP). An agent can tell exactly what this tool does without opening the schema.

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

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

The description gives a clear context for when to use the tool: when selecting legal monsters for an encounter budget. It also implies a comparison to alternatives by specifying 'SRD monsters' and 'legal', but it does not explicitly name alternative tools or state when not to use this one. Still, the use case is concrete enough to guide an 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?

With no annotations, the description carries the full burden. It explicitly states the operation is a read and discloses the exact return structure {path, frontmatter, body}, which is transparent and actionable. It does not mention failure behavior for missing paths, but this is minor for such a simple read 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 a single, front-loaded sentence that communicates both purpose and return shape with zero filler. 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?

For a one-parameter read operation, the description provides the core behavior and return shape, which is helpful especially given there is no output schema. However, the lack of path parameter semantics leaves a meaningful gap: an agent must infer how to supply the path. It is minimally adequate 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 description coverage is 0% and the only parameter 'path' has no schema description. The description adds minimal context by implying the path refers to a vault note, but it does not clarify path format, vault-root relativity, file extensions, or valid values. The description does not sufficiently compensate for the missing schema coverage.

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

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

The description states a specific verb ('读取' / read) and resource ('vault 笔记'), and also specifies the exact return shape {path, frontmatter, body}. This clearly distinguishes it from siblings like create_note, list_notes, and semantic_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?

There is no guidance about when to use this tool versus alternatives such as list_notes or semantic_search. The intended use is implied by the name and description, but no exclusions, prerequisites, or comparison with sibling tools are 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 provided, the description carries the behavioral burden, and it does disclose the important special cases: nat20 always hits and crits, nat1 always misses. However, it omits the core resolution behavior, such as comparing d20 + attack_bonus against target_ac and how advantage/disadvantage affect the roll.

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 no wasted words, and it front-loads the core purpose before adding the key natural-roll rules. Every clause 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 four parameters, two of which are booleans, no annotations, and no output schema, the description is under-specified. It leaves the main hit/miss math and the effect of advantage/disadvantage unstated, so an agent would need external D&D knowledge to call the tool correctly in non-trivial cases.

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, so the description must compensate, but it never explains attack_bonus, target_ac, advantage, or disadvantage. It adds only the d20/nat context, leaving the meaning of all four parameters to be inferred from their names and standard D&D conventions.

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 a specific action, '解析攻击骰' (resolve attack roll), and adds the critical nat20/nat1 rules, making the tool's purpose evident. However, it does not explicitly contrast itself with siblings such as resolve_check or roll_dice, so it falls short of full differentiation.

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

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

Usage is implied by the name and wording: the tool should be used when resolving an attack roll. But the description gives no explicit guidance about when not to use it or which sibling tool to prefer for related cases like general checks or damage rolls.

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 usefully discloses that nat20/nat1 do not automatically succeed/fail and that resolution is d20 + modifier vs DC. However, it does not state whether the tool rolls the d20, how advantage/disadvantage interact, or what the result looks like.

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

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

Two short sentences, front-loaded with the core formula followed by the critical crit rule. There is no filler or repetition, and every clause adds useful information.

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 5 parameters, no annotations, and no output schema. The description covers the basic comparison logic but omits the return value, advantage/disadvantage behavior, and how proficiency_bonus should be applied. This is not complete enough for an agent to confidently invoke the tool in edge cases.

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 clarifies the meaning of "dc" and "modifier" through the formula, but advantage, disadvantage, and proficiency_bonus are left completely unexplained, leaving the agent to guess how they combine with modifier.

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

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

The description states a clear verb and resource: "解析属性/技能/豁免检定" (resolve ability/skill/saving throw checks) with the formula d20 + modifier vs DC. It also adds a differentiating mechanical trait (nat20/nat1 do not auto-succeed/fail), which helps separate it from attack or damage tools, though it never explicitly contrasts it with siblings like resolve_attack.

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 the use case: ability checks, skill checks, and saving throws. It gives clear context but no explicit exclusions, no guidance on when to prefer roll_dice or resolve_attack, and no note about how advantage/disadvantage should be passed.

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 full behavioral burden. It discloses a key ambiguous rule: a crit only doubles the dice count while the modifier is added once. This is genuinely useful behavioral context, though it doesn't mention parsing rules or output format.

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 short primary statement followed by a single scoping rule. Every sentence earns its place, and the core purpose 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?

The tool is simple enough that this brief description covers the main call semantics, and no output schema exists to explain returns. Still, it lacks dice_notation examples, any indication of what the result looks like, and when to prefer roll_dice instead, leaving moderate 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. It adds meaning to crit (doubles dice only) and modifier (added once), but it never explains the dice_notation string syntax, which is the only required parameter.

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

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

The description states a clear verb and resource: '掷伤害' (roll damage), which tells the agent this tool resolves damage rolls. It also hints at specifics like crit and modifiers, distinguishing it from the generic roll_dice sibling, though it never names that sibling explicitly.

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

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

Usage is implied: this is for rolling damage, with crit and modifier behaviors explained. However, there is no explicit guidance on when to use this tool versus roll_dice, resolve_attack, or resolve_check, and no exclusions or alternatives are named.

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 explicitly lists the return structure (notation, rolls, natural, modifier, advantage, disadvantage, crit, total) and explains the special case for 'natural' (only for a single die). This is valuable behavioral disclosure beyond the schema. It does not mention error handling or side effects, but for a dice roller this is a minor 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 compact—four short sentences in Chinese—with no redundancy. It front-loads the core purpose, then provides usage constraints, then the output structure, and finally a nuance. Every sentence adds information, making it highly 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 tool has 4 parameters and no output schema, the description covers most essentials: notation, advantage/disadvantage constraints, and the return format. However, it omits the behavior of the 'crit' input parameter and does not mention error handling for invalid notation. These are gaps that could confuse an agent, but the core usage is understandable.

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 explain parameters. It explains the 'notation' format with an example and clarifies the semantics of 'advantage' and 'disadvantage' (single d20 only). However, the 'crit' parameter is only mentioned in the return structure, not explained as an input—its purpose (e.g., force a critical hit) is left unclear. Thus partial coverage.

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 function: '掷骰' (roll dice) and provides the notation format example. It distinguishes itself from siblings like roll_damage by implying it is the generic dice roller, though it does not explicitly name alternatives.

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

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

The description gives a specific constraint: advantage/disadvantage only works for a single d20, which tells the agent when these parameters are appropriate. However, it does not explicitly mention when to use roll_dice versus siblings like roll_damage or resolve_check, leaving the selection partly to inference.

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

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

Discloses the filtering behavior (empty campaign/ruleset = unlimited, given campaign = that campaign + shared rules) and the requirement of an existing index. Since no annotations are provided, the description carries the full burden; it provides key behavioral info about return format and read-only nature, though explicit read-only declaration is missing but implied.

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 concise sentences, front-loading the main purpose, then clarifying scope and providing alternative and prerequisite. No waste and well structured.

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

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

Covers the essential information: what it does, output format, scope filtering, alternative tools, and prerequisite. Lacks explicit error handling and pagination, but sufficient for a search tool given no output schema and simple parameters.

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

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

The description explains the semantics of campaign and ruleset parameters explicitly (scope filtering), and implies query is the search text via the main purpose. However, k is not mentioned, and with 0% schema coverage, the description should ideally explain all parameters. It partially compensates but misses k.

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

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

States a specific verb (semantic search), resource (SRD narrative + indexed module prose), and output (fragments with citations). Explicitly differentiates from lookup_* tools for exact values, which distinguishes it from sibling tools like lookup_rule and lookup_spell.

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 when to use: semantic search for narrative/prose, and when not to: exact numeric values should use lookup_* tools. Also clarifies scope filtering (campaign/ruleset behavior) and prerequisite (index must be built).

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 and it clearly states how the inputs are combined. The formula fully describes the pure-calculation behavior; it does not mention side effects or return type, but those are less critical for a simple calculator.

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 compact formula with no filler. It is front-loaded and every part contributes to understanding 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?

For a two-integer pure calculation, the formula plus the schema is nearly complete. It does not explicitly state that the return value is the computed integer sum, but that follows directly from the formula.

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 does so by defining the relationship between the two parameters: ability_mod plus proficiency_bonus. The mapping from Chinese terms to property names is implicit but recoverable.

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 exact computation: spell attack bonus equals proficiency plus ability modifier. This makes the resource and operation clear, and the formula differentiates the tool from sibling spell_save_dc even without explicitly naming an alternative.

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

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

The description gives no guidance on when to use this tool versus alternatives like spell_save_dc, resolve_attack, or roll_dice. The only usage cue is the formula itself, so the agent must infer 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 provided, the description carries the full burden of behavioral disclosure. It clearly reveals a pure arithmetic calculation with no hidden side effects. It does not state the output type or any special cases, but for a simple formula tool this is a minor 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 entire description is one compact formula with no filler. The essential computational rule is immediately visible and every word contributes to understanding 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?

For a two-integer deterministic computation, the formula makes the tool essentially self-explanatory. It lacks an explicit statement of the return format, but the high-level behavior and inputs are complete enough for correct invocation.

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 fully compensates by giving the exact mathematical role of each parameter. It shows that ability_mod and proficiency_bonus are added to the constant 8, which is meaning the schema alone does not provide.

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 computes spell save DC using the standard formula '8 + proficiency + ability modifier.' It is unambiguous, though it is presented as an equation rather than an explicit verb phrase and does not directly mention sibling tools such as spell_attack_bonus.

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?

There is no explicit statement about when to use this tool versus alternatives like spell_attack_bonus or roll_dice. The intended use is strongly implied by the formula and tool name, but the description provides no reasoning guidance or exclusions.

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

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

No annotations were provided, so the description carries full behavioral burden. It discloses that the tool writes to variants/<variant>/, leaves templates untouched, auto-generates ids, sorts combatants by initiative descending, and initializes round=1/turn_index=0. These are concrete side effects and state mutations.

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

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

Two sentences deliver the core purpose, location, non-destructive behavior, combatant schema, and initialization details with no filler. Important constraints 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 essential side effects, required combatant fields, sorting behavior, and initial state. With no output schema or annotations, it doesn't describe return values or error conditions, but the available information is sufficient to correctly construct and invoke the tool for the main use case.

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 compensates by defining the combatants item structure (name/side/initiative/ac/hp{value,max,temp?}) and explaining the variant parameter as a path segment. It does not elaborate on summary/terrain/campaign, but these are relatively self-explanatory or optional.

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 uses a specific verb ('start a runtime encounter'), names the exact resource location ('variants/<variant>/'), and distinguishes itself from template editing ('doesn't touch template'). This also separates it from sibling management tools like manage_combat_state or update_campaign_state.

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?

States that it starts a runtime encounter and explicitly says it does not modify the template, which clarifies when this tool should be used as opposed to editing encounter templates. It doesn't name sibling tools or spell out when not to use it, but the 'runtime vs template' distinction provides clear 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?

Annotations are absent, so the description must disclose all behavioral traits. It merely states the mapping function without indicating whether the operation is read-only, whether it has side effects, or how it handles edge cases. No mention of error conditions, rate limits, or expected output structure, making behavioral expectations 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 short (one sentence), which is concise and avoids verbosity. However, it's so minimal that it borders on under-specification rather than deliberate conciseness. The information is front-loaded, but the structure lacks any breakdown or expansion, making it feel incomplete.

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 two parameters, no annotations, and no output schema, the description is severely incomplete. It fails to explain what the term parameter accepts, how direction is used, what the return value looks like, or any error behavior. An agent would have no idea how to call this tool correctly without additional context.

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 explain the parameters. It indirectly references the direction parameter by listing 'en2zh / zh2en', but it never describes the 'term' parameter or its expected format. The default for direction is not explained beyond the direction list, and no examples are given, leaving both parameters under-specified.

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

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

The description states a clear verb-resource pair: mapping terms between Chinese and English, and explicitly lists the supported directions (en2zh / zh2en). This makes the tool's purpose specific and distinct from the unrelated sibling tools, though it doesn't elaborate on whether it's a direct translation or a lookup of a terminology database.

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. The sibling list contains no translation-related tools, so there's no explicit comparison, but the description also fails to mention any prerequisites or typical use cases, leaving the agent to infer 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 of behavioral disclosure, and it does so well. It explicitly explains the merge strategy ('world_flags 增量合并（不清旧旗标），其它 key 整体替换'), the auto-creation behavior, and the return value ('返回合并后状态'). This gives the agent a clear mental model of 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 two dense sentences with no fluff. It front-loads the core action, then delivers important merge behavior and return information efficiently.

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 behavior, merge rules, and return value, which is useful given the lack of an output schema. However, it leaves key parameter context undocumented (especially 'campaign' and 'variant'), and it does not relate to sibling state-management tools, so the description is not fully complete for safe invocation.

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 only indirectly explains the 'patch' parameter by listing possible keys it can contain. The required 'campaign' parameter and the 'variant' parameter are not described at all, leaving their meaning and default behavior ambiguous.

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 identifies the action ('合并 patch'), the resource ('运行态 state.md'), and the affected key groups ('current/clocks/quests/world_flags 等'). It also distinguishes the tool by specifying exact merge semantics, which separates it from sibling state tools like manage_combat_state.

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—whenever a patch should be merged into the running campaign state—and adds the useful context that it auto-creates the state file on first use. However, it does not explicitly address when to choose this tool over alternatives, nor does it state any usage exclusions.

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

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

With no annotations provided, the description carries the full burden. It discloses deterministic behavior ('确定性') and the return structure, but does not state whether the operation is read-only, what happens on invalid input, or any side effects. It adds some behavioral context beyond a bare statement of purpose but leaves notable gaps.

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, tightly packed sentence that leads with the action, enumerates the checkable issues, and states the return shape. There is zero redundant wording; every clause 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?

For a single-parameter tool with no nested objects and no output schema, the description covers the purpose, the parameter's role, the specific validation checks, and the return structure. It is largely complete for an agent to call correctly, though it omits potential edge-case behavior or required preconditions like the campaign existing.

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 provides only a 'campaign' string with no description (0% coverage). The description clarifies that 'campaign' refers to the campaign module whose dependency graph is to be validated, and that it is echoed in the return. This adds meaningful semantic context beyond the raw schema, though it does not specify the expected format or identifier scheme.

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

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

The description states a specific verb 'validate', a specific resource 'campaign module dependency graph', and enumerates the three issue types checked. It distinguishes itself from sibling tools by being the only validation tool, and clearly states its purpose without 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 gives no guidance on when to invoke this tool versus alternatives, nor any conditions that would make it inappropriate. It simply states what it does; there is no mention of context, prerequisites, or exclusions.

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