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. It says nothing about mutation effects, required permissions, side effects, validation, or return values. For a creation tool with nested conditions and no output schema, this is a severe 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 a single short phrase, which is concise but under-specified rather than efficiently informative. It is front-loaded but lacks any structure or helpful detail.

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 (7 parameters, nested objects, an enum, no annotations, no output schema), the description is completely inadequate. It fails to explain core concepts an agent needs to invoke the tool correctly.

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 mentions only that conditions are involved. It does not explain the 7 parameters, their formats, the meaning of branch_kind (soft/hard), or the structure of conditions. This leaves the agent entirely dependent on the raw 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 '添加带条件的分支边' translates to 'Add a conditional branch edge', which restates the tool name and title rather than adding distinguishing information. It vaguely indicates the resource (branch edge) and a characteristic (with conditions), but provides no clarity on how it differs from close siblings like connect_branch or connect_nodes.

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 indication of when to use this tool versus alternatives such as connect_branch or connect_nodes. No context, prerequisites, or exclusions 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?

No annotations are provided, so the description carries the full behavioral burden, and it discloses nothing. It does not state whether advancing is reversible, what preconditions must hold (thread exists, phase transition legal), what side effects occur, or what permissions are 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?

A single short phrase is not wasteful in length, but it is under-specification rather than conciseness. There is no front-loaded actionable content beyond the title restated.

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 three-parameter mutation tool with no annotations, no output schema, and no parameter documentation, the description is completely inadequate to let an agent invoke it correctly.

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% across three parameters (thread_id, project_id, target_phase_id), and the description explains none of them. In particular, the semantics of target_phase_id and the optional project_id are entirely undocumented.

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 '推进 Meta 线程阶段' merely restates the tool name (advance_thread_phase) in Chinese without adding any distinguishing detail. It does not clarify what 'Meta thread' or 'advancing' a phase entails, nor differentiate it from siblings like check_thread_health, register_thread, or link_beat_to_thread.

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, when not to, or which sibling to prefer. With dozens of thread-related siblings (check_thread_health, register_thread, check_unresolved_threads), the agent has no way to choose correctly.

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 behavioral burden. It does not disclose whether this is a read-only diagnostic or a mutating fix, whether it needs a registered arc, or what form the findings take. Only the general nature (issue detection) is conveyed.

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 short sentence with no waste, but it is under-specified rather than genuinely concise — there is little content to front-load and the description does not earn its place as a routing aid.

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-parameter tool with no output schema and no annotations, the one-line description leaves too much open: input expectations, output shape, and how results differ from other narrative checks. More detail is needed to call it correctly.

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% for two parameters (arc_id, project_id), yet the description names neither. That the tool operates on a character arc weakly implies arc_id, but project_id and the required/optional status are left completely undocumented.

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 (分析/analyze) and resource (角色弧光/character arc), and goes further by naming the class of issues detected (平坦/flat, 矛盾/contradictory). It is clear what the tool does, but it offers no differentiation from adjacent validators such as validate_project, check_canon, or check_ludo_narrative.

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 statement of when to use this tool versus the many other check/validate/analyze siblings, and no prerequisites (e.g. must the arc already exist, must a project be active). Usage must be entirely inferred from the name.

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 behavioral burden, yet it does not say whether this is a read-only analysis or a mutation, whether it requires auth, or what the result contains. It only restates the check categories already implied by the tool name, adding almost no behavioral context.

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

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

The single Chinese phrase is front-loaded and contains no filler, but it is under-specified rather than concise — for a three-parameter analytical tool the brevity leaves the agent without the information it needs.

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 annotation coverage, zero schema description coverage, no output schema, and three parameters (one required), the description is not complete enough to invoke the tool reliably. It omits parameter meaning, usage context, and return behavior, and is even written in a different language from the tool name and siblings.

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 should explain the three parameters, but it only loosely gestures at consecutive_high_count via '连续高压'. Neither curve_id (required) nor project_id is explained, and it never clarifies whether counts are thresholds that change the analysis 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 specific analytical verb (检查/check) and lists three concrete pacing problems (consecutive high tension, emotional interruption, reveal beats), which is more specific than a tautology. However, it never distinguishes this tool from close siblings such as configure_pacing or suggest_next_beat, so an agent cannot tell from the text alone why it should pick this one.

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 statement of when to use this tool, what preconditions apply (e.g. an existing curve_id), or which alternative (configure_pacing) should be used instead. The agent must infer usage entirely from the name and the parameter list.

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 entire behavioral burden and supplies none of it: it does not say what canon is, what is compared against what, whether it is read-only or mutating, whether it fails or reports violations, or what the result looks like. This is a bare restatement of the name.

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 short phrase with zero padding and is front-loaded, but the brevity is the result of under-specification rather than disciplined editing. Concise, yet almost no information is conveyed.

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?

With no annotations, no output schema, an undocumented parameter, and a domain ('canon consistency') that requires explanation, the definition is far too thin for an agent to invoke it confidently. Nothing tells the agent what a successful or failing check means.

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 single parameter project_id has no description anywhere. The description never mentions project_id, so it fails to compensate for the documentation gap, though the parameter name is at least 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 gives a verb ('检查'/check) and a resource ('canon consistency'), so the general intent is legible, but 'canon' is domain jargon left unexplained and nothing distinguishes it from siblings such as check_ludo_narrative, check_knowledge, check_timeline or validate_project. It states a purpose without clarifying scope.

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 run this check, what triggers it, whether it must run before/after other operations, or which sibling validation tool to prefer. The agent is left to guess from the name alone.

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, and it discloses nothing: no statement of what is validated, what a failure looks like, whether it mutates state, or what permissions or prerequisites apply.

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?

It is short, but that brevity is under-specification rather than conciseness, and the mixed-language phrasing leaves the meaning ambiguous rather than front-loading a clear purpose.

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-parameter validation tool with no annotations and no output schema, the description provides nothing an agent needs to invoke it correctly; it is effectively unusable as a selection signal.

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% for both event_id and project_id. The description's only clue is the word 'event' (事件), and it says nothing about project_id or the relationship between the two parameters.

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 is a garbled phrase mixing Chinese and English ('检查事件 assumes 是否被 reveals 覆盖') that gestures at event/reveal coverage checking but never states a clear verb+resource. An agent cannot reliably determine what this tool does or how it differs from siblings like check_canon, check_thread_health, or get_player_knowledge_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?

There is no indication of when to use this tool, when not to, or which sibling to prefer. With roughly 60 sibling tools including several other 'check_*' validators, the absence of routing guidance is a serious gap.

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 behavioral burden, and it discloses almost nothing: no read-only guarantee, no statement of what is inspected (UI strings? glossary terms? scene text?), no indication of whether it mutates state, and no hint at the result shape. 'text overflow' is the only behavioral clue.

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 short sentence with no filler and the key concept front-loaded. It is efficiently sized, though the brevity is partly under-specification rather than disciplined 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?

With no annotations, no output schema, an undocumented parameter, and an unclear scope of what 'localization issues' covers, the definition leaves too much unspecified for an agent to invoke it confidently. It falls short of what a one-parameter validation tool needs.

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 is one parameter (project_id) with 0% schema description coverage, and the description says nothing about it, so the agent cannot tell whether it is required, optional, or defaults to the active project. The description does not compensate for 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?

It names a specific verb+resource (check / localization) and gives a concrete example of the class of problem ('text overflow'), which is more informative than a bare restatement of the title. It does not, however, distinguish itself from nearby validation siblings such as validate_project or check_scene_against_rules.

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 indication of when this check should be run, whether it requires an initialized project, or how it relates to register_localization_rule. The agent must infer usage entirely from the name.

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 behavioral burden. It names the conflict categories inspected but says nothing about whether it is read-only, what a conflict result contains, severity levels, or whether project_id is required. A diagnostic tool with zero annotation coverage needs more than a category list.

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 compact sentence with the verb and scope front-loaded and no filler. Efficient, though the parenthetical detail is the only content and nothing else earns space.

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 diagnostic check tool with no output schema and no annotations, the description should at minimum convey what a result looks like and what input is needed. As written, an agent cannot predict the response shape or confirm whether project_id is required.

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 project_id has 0% schema description coverage and is never mentioned in the description, so there is no guidance on its format, source, or whether omission defaults to the active project. Baseline is not met because the one existing parameter is undocumented in both places.

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 (检查) and resource (玩法-叙事冲突), then narrows the scope to NPC状态、flag、gameplay模式. An agent knows this is a targeted conflict-detection check, though it does not distinguish itself from sibling checks like check_canon or check_thread_health.

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 indication of when to run this check versus the many other check_* siblings, no prerequisites, and no ordering guidance relative to validate_project or register_* tools. Usage must be inferred entirely from the name.

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, and it discloses nothing: not whether the check is read-only, what conditions constitute "unhealthy," whether it requires an active project, or what it reports. This is a total gap for a diagnostic 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 short and front-loaded, but its brevity reflects under-specification rather than economy. One vague sentence cannot earn credit for conciseness when it omits everything substantive.

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 diagnostic tool with no annotations, no output schema, and an undocumented parameter, the description provides nothing an agent needs in order to invoke it correctly or interpret results.

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 single parameter project_id is undocumented in both the schema and the description. The description does not mention parameters at all, so it fails to compensate for 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 ("检查事件池健康度") essentially restates the tool name check_pool_health, adding only the word "event" to specify the pool type. It does not say what "health" means or what is actually inspected, so an agent cannot distinguish it meaningfully from siblings like check_thread_health or check_canon beyond the noun.

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 call this tool, what state it should be used in, or which sibling health-check tools are alternatives. The agent is left to infer usage entirely from the name.

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 does not say whether the check is read-only, whether it fails or returns a report, whether content rules must already be registered, or what scope project_id imposes.

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 parenthetical phrase is front-loaded and wastes no words, though the extreme brevity is partly the cause of the other gaps.

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-parameter validation tool with no annotations and no output schema, the definition leaves the return values, required inputs, and preconditions unspecified, which is inadequate to call it confidently.

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 neither parameter has a description. The description never mentions event_id or project_id, nor which is required (the schema marks none as required), so it adds nothing over 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?

States a specific verb (check) and resource (event) plus the rule dimensions examined: banned words, word count, glossary, character voice. This distinguishes it from siblings like check_canon, check_localization, and validate_branch_graph, though it does not explicitly name which sibling to prefer.

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 indication of when to invoke this versus check_canon, validate_project, or any other check tool, nor any prerequisite such as content rules first being registered via register_content_rules. Usage must be entirely inferred from the name.

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, yet it discloses nothing beyond the name: no indication that this is a read-only diagnostic, what 'health' means, what a failing thread implies, or what the result contains. For a health-check tool with zero annotation coverage this is a significant 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 only a fragment, so it is short but not by economy — it is under-specified rather than concise. There is no wasted text, but nothing is front-loaded because nothing substantive is stated.

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?

With no output schema and no annotations, the description is the only artifact that could explain the check's result and preconditions, and it supplies none of that. For a diagnostic tool in a dense sibling ecosystem this is insufficient to call the tool correctly.

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 is one optional parameter, project_id, with 0% schema description coverage, and the description never mentions it. An agent cannot tell whether the check operates on the active project or requires an explicit project_id, nor what format the id takes.

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 phrase '检查 Meta 线程健康度' gives a clear verb ('check') and a resource ('Meta thread health'), which is more than a tautology of the name. However, it does not distinguish this tool from close siblings such as check_pool_health and check_unresolved_threads, and 'Meta 线程' / '健康度' are not defined here. Adequate but not differentiating.

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 statement of when to use this tool, when not to, or which sibling to prefer for overlapping concepts like thread vs. pool health. The agent must infer usage entirely from the name and the surrounding tool list.

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 behavioral burden. It discloses what is detected (causal contradictions and cycles) but says nothing about severity of findings, whether the timeline is mutated, required permissions, or what happens when no project_id is given.

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 short phrase, front-loaded and free of waste, but it is terse to the point of under-specification for a validation tool. The brevity serves the reader only because there is so little content to convey.

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?

With no annotations, no output schema, zero parameter documentation, and dozens of sibling tools, the description leaves critical gaps: it does not say what the result looks like, whether the check is read-only, or how to scope it to a project. Only the core purpose is conveyed.

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 single parameter, project_id, is undocumented in both schema and description. The description does not mention that a project must be identified, nor that the parameter is optional, leaving the agent to guess the scope of the check.

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 ('检查' / check) and resource ('时间线' / timeline) and names the exact class of problems detected: causal contradictions and cycles. This distinguishes it reasonably from siblings like check_canon or validate_project, though it does not name 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?

There is no guidance on when to run this check, at what stage of the workflow, or how it relates to sibling validators such as validate_branch_graph or check_canon. The agent must infer usage entirely from the tool name and the phrase about causal contradictions.

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 exist, so the description carries the full burden. It implies a read-only listing, but says nothing about scope (project-wide vs. depth-bounded), cost, or what “expired” means operationally — a notable gap given the max_depth/current_depth parameters hint at traversal 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?

It is a single short front-loaded phrase with no filler, which is efficient. But it is under-specified rather than truly concise, and the language mismatch with the English tool name and siblings adds friction.

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 3-parameter tool with no annotations, no output schema, and no parameter documentation anywhere, this one-line description is insufficient. An agent cannot know what the depth parameters do or what shape the danger-signal results take.

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?

All three parameters (max_depth, project_id, current_depth) have 0% schema description coverage, and the description mentions none of them. The schema fields most in need of explanation — the depth-traversal pair and project scoping — are entirely undocumented.

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-plus-object (“list unresolved/expired foreshadowing”) and even characterizes the output as danger signals. However, it does not distinguish itself from the closely related sibling check_thread_health, leaving the agent to infer the boundary.

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 statement of when to call this tool, what preconditions apply, or which sibling to reach for otherwise. The only implicit cue is that it surfaces problems, which is not the same as 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 carries the full behavioral burden, and it says nothing about cost, whether comparison requires prior simulation runs, how seed and runs_per_ending affect determinism, or what the comparison outputs. The presence of a seed and runs_per_ending implies sampling/simulation is involved, but that is never made explicit.

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 short clause with no filler and the core action front-loaded. Brevity is a virtue here, though the terseness is partly under-specification rather than disciplined concision.

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 four-parameter analytical tool with no annotations, no parameter descriptions, and no output schema, one line of description is far too thin. An agent cannot tell what inputs are needed, what the comparison returns, or whether it is expensive to call.

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 four parameters (seed, ending_ids, project_id, runs_per_ending) are entirely undocumented. The description hints at ending_ids and event-overlap concepts, but says nothing about seed, project_id, or how many runs are needed, leaving most parameters unhinted.

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 (对比/compare) and a specific object: multi-ending condition differences plus overlap of experienced events. That is more than a restatement of the title. It does not, however, distinguish itself from nearby siblings such as map_ending_space or simulate_run, which also operate on endings.

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 statement of when to reach for compare_endings rather than map_ending_space, simulate_run, or register_ending_axis. No prerequisites, no exclusions, no context about what kind of question this tool answers.

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 disclosure burden and fails it: it does not say whether weights are persisted or merely returned, whether the computation is deterministic, whether it mutates pool state, or what permissions/project scope are needed. Only the pool-scoping constraint is 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?

A single seven-character phrase is technically concise but is under-specification rather than efficiency; there is no front-loaded framing of purpose, inputs, or outcome to structure an agent's decision.

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-parameter computation tool in a large narrative-engine toolset with no annotations and no output schema, the description should explain the computation's result and prerequisites. It omits both, so an agent cannot confidently call it correctly.

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% for two parameters, and the description adds no meaning for 'pool_id' (required) or 'project_id' (optional) — notably it never explains why an optional project scope exists alongside a pool id. Nothing compensates 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 phrase '计算池内事件权重' names a concrete verb (compute) and a concrete object (event weights inside a pool), so the basic operation is inferable. However, it says nothing about what these weights are used for, what 'pool' scoping means, or how this differs from the sibling 'explain_weight', leaving the purpose only half-specified.

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 indication of when this tool should be invoked, what prerequisite state is required (e.g., that the pool must already be registered via 'register_pool'), or which sibling to use instead for related weight inspection (e.g., 'explain_weight'). Usage must be entirely 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?

No annotations are provided, so the description carries the full behavioral burden, and it discloses nothing. It does not say whether this creates or overwrites a pacing curve, whether the write is destructive to existing beats, what permissions are needed, or what happens on partial input.

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?

It is a single short phrase with no filler, but brevity here reflects under-specification rather than conciseness. There is no front-loaded statement of scope, effect, or constraints for an agent to act on.

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 mutation tool with five parameters, a complex nested beats array, no annotations, and no output schema, the description is completely inadequate. An agent cannot determine what a pacing curve is, what shape of data to submit, or what the call will do to project state.

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 across 5 parameters, including a nested 'beats' array with 14 sub-fields such as depth, emotion, gameplay_mode, and estimated_duration_minutes. The description explains none of these, leaving the semantics of required id/name and the entire beats structure undocumented.

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 '配置节奏曲线' (configure pacing curve) merely restates the tool name and title in another language, adding no distinguishing detail. It does not differentiate itself from siblings such as analyze_pacing, suggest_beat, or suggest_next_beat, which all concern pacing.

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 indication of when to use this tool versus analyze_pacing, suggest_beat, or the other pacing-adjacent siblings. The agent is left to infer usage entirely from the name.

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 says nothing about persistence, scope (global vs. per-project despite a project_id parameter), reversibility of the change, or default behavior when optional fields are omitted — only 'configure' implies mutation.

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?

It is short, but brevity here comes from under-specification rather than economy — a single terse phrase with no substance, similar to a stub. Nothing is front-loaded because nothing is said.

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?

A five-parameter configuration mutation with no annotations, no output schema, and no parameter documentation leaves an agent unable to call it correctly beyond guessing at mode. The description is wholly inadequate 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 description coverage is 0% across five parameters, so the description must compensate, and it does not: soft_cap, max_depth, tick_unit, and project_id are entirely unexplained. It only echoes the mode enum values, which the schema already declares.

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 gives a specific verb+resource (配置 Run 引擎) and names the two mode values the tool operates on, which matches the schema enum. It does not differentiate itself from siblings such as configure_pacing or simulate_run, so it stops short of a 5.

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 statement of when to use this tool, when not to, or which alternative sibling to reach for. The parenthetical mode list is configuration content, not usage 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?

No annotations are provided, so the description carries the full behavioral burden. It implies a mutation (creating an edge) but says nothing about permissions, whether the edge is validated against the branch graph, idempotency, or what 'unconditional' means operationally. Only a faint hint is given.

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?

It is a single short line with no padding and the key qualifier front-loaded, which is structurally fine. It is arguably over-terse rather than concise, but there is 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?

With no annotations, no output schema, 0% parameter coverage, and three similarly-named siblings, the description leaves the agent without enough to invoke the tool confidently. It should at minimum explain what distinguishes an 'unconditional' edge from the conditional path and what the parameters mean.

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% across three parameters (from_id, to_id, project_id), and the description adds no semantics for any of them. The 'edge/connection' framing loosely implies from/to endpoints are the two node ids, but their format, directionality, and the optional project_id are undocumented everywhere.

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 Chinese description states a specific verb and resource ('connect branch graph edge'), which is more than a tautology of the name. However, it does not distinguish itself from the very similar sibling tools connect_nodes and add_branch_edge, so an agent cannot tell which of the three to pick from the description alone.

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 parenthetical '(unconditional shortcut)' hints that this variant skips conditions, but there is no explicit statement of when to use this rather than add_branch_edge or connect_nodes, nor any prerequisites or exclusions. Usage must be 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?

No annotations are provided, so the description carries the full behavioral burden, and it discloses nothing: not whether nodes must pre-exist, whether connections are reversible, whether cycles are permitted, what authorization or project scoping applies, or what gets returned. For a mutation tool this is a total 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?

It is short and has no filler, but the brevity reflects under-specification rather than economy; the single clause is too thin to earn its place as a tool description. The alias note is front-loaded, which is the one structural merit.

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?

A three-parameter mutation tool with no annotations, no output schema, and 0% parameter documentation needs the description to do substantial work, and it does essentially none. An agent has no basis to call it correctly or distinguish its effect from connect_branch.

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% across three parameters (from_id, to_id, project_id), and the description supplies no meaning for any of them — not the expected ID format, nor why project_id is optional while the two IDs are required. It adds nothing beyond the raw 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 'connect_branch alias: connect two branch nodes' largely restates the tool name and title rather than specifying a distinct verb+resource beyond what 'connect_nodes' already conveys. The only added information is the alias relationship to connect_branch, which weakly distinguishes it from siblings but does not explain what a 'branch node' connection actually produces.

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 implies equivalence with the sibling connect_branch, which is marginally useful routing information, but there is no guidance on when to prefer this tool over connect_branch, add_branch_edge, or register_branch_node. No prerequisites, context, or exclusions 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?

No annotations are provided, so the description carries the full burden of behavioral disclosure. It does not state whether this is a write operation (though 'create' implies it), what permissions are required, whether it overwrites existing data, or what happens with partially specified parameters. The description offers no behavioral context beyond the implied creation.

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 that is front-loaded with the key action and qualifiers. It is efficient and contains no wasted words, though its brevity comes at the cost of missing 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 6 parameters, no annotations, and no output schema, the description is incomplete. It lacks essential context such as prerequisites, the expected input format, the effect of batch creation, and how this tool fits with siblings. An agent would need to guess many details to invoke it correctly.

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% for 6 parameters, so the description must compensate. It only mentions Act and '深度' (depth), which loosely correspond to the 'act' and 'depths' parameters, but does not explain the required 'curve_id', 'name', 'project_id', or the enum values for 'default_type'. The description fails to provide meaning for most parameters.

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 '按 Act/深度批量创建节奏板' states a verb (create), a resource (节奏板/beat sheet), and a qualifier (by Act/depth, batch). It distinguishes itself somewhat from siblings like register_beat or update_event by emphasizing batch creation, but the relationship to sibling tools like register_beat is not clarified. Purpose is vague enough that an agent may not fully differentiate it.

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 such as register_beat, update_event, or configure_pacing. The tool is one among many beat-related siblings, but no context is given for when batch creation is appropriate. No when-not or alternative-tool instructions are present.

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 neither states that this is a read-only scan nor clarifies whether resolving the 'current active project' mutates any state — a crucial distinction given that set_active_project is a sibling that clearly does mutate state.

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 compact sentence with the resource and scoping root front-loaded and no wasted phrasing. It is appropriately sized, though the trailing clause about the active project is slightly ambiguous rather than wasteful.

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?

With no output schema and no annotations, the description should explain what a 'discovered' project looks like and, critically, whether resolving the active project changes state. Neither is covered, and the relationship to set_active_project/list_projects is unaddressed, leaving a meaningful gap for a nullary discovery 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?

The tool takes zero parameters, so the baseline is 4. The description does add the contextual detail that the scan is rooted at NARRATIVE_DATA_ROOT, which explains the implicit input source in the absence of parameters.

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 specific verbs (扫描/scan, 解析/parse) and a specific resource (narrative projects under NARRATIVE_DATA_ROOT), plus the notion of resolving the active project. It is distinguishable from a generic list, but it does not explicitly differentiate itself from the closely related siblings list_projects and get_project.

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 statement of when to use this tool rather than list_projects, get_project, or set_active_project, and no prerequisites or exclusions. The agent is left to infer its place in the discovery workflow from the name alone.

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 entire behavioral burden. The word 'roughly' hints that the result is an approximation rather than an exact count, which is genuinely useful, but nothing is said about cost, side effects, auth requirements, or what the estimate is based on.

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 short fragment with no structure. This is under-specification rather than conciseness: there is no wasted sentence, but there is also no front-loaded purpose statement or scope to anchor the agent.

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?

With no annotations, no output schema, an undocumented parameter, and undefined jargon, the definition leaves too much unstated for an estimation tool in a crowded sibling set. An agent could invoke it, but not confidently.

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% for the single parameter project_id, and the description adds no information about it (e.g., whether it is required, what happens when omitted, or whether it defaults to the active project). The description fails to compensate for 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 fragment names an action ('roughly estimate') and a resource ('branch path count and soft/hard branch volume'), which is more than a restatement of the title. However, 'soft/hard branch volume' is undefined domain jargon, so an agent cannot be fully certain what is computed. It does contrast implicitly with siblings like validate_branch_graph or simulate_path, but only weakly.

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 indication of when to use this tool versus validate_branch_graph, simulate_path, or add_branch_edge. There are no prerequisites, exclusions, or alternative-routing cues of any kind.

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 disclosing behavioral traits. It only lists estimated metrics and omits whether the operation is read-only, what project_id should reference, what happens if project_id is absent, or how results are returned.

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 terse clause with no padding, but it is under-specified rather than appropriately concise. It lists metrics without front-loading any operational context the agent would need.

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 estimation tool with no output schema and no annotations, the description should explain what is being read and what the result contains. The metric list is a start, but key operational context is missing.

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 project_id has 0% schema description coverage, and the description never mentions it or explains what it should contain. The description adds no parameter-level 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?

States a specific verb (估算) and enumerates four estimation targets: word count, option count, VO sentence count, and localization key count. This is more specific than a title restatement, but it does not distinguish itself from sibling estimation tools such as estimate_branching_factor.

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 no when-to-use guidance, no prerequisites, and no mention of alternatives. An agent must infer the appropriate context entirely from the tool name.

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 behavioral burden. It conveys only that the tool explains a calculation; it does not state that it is read-only, whether it requires the event to exist, or what form the explanation 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?

A single short phrase with no padding and the key concept front-loaded, so it is concise. It is arguably over-terse given the zero documentation elsewhere.

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 parameterized tool with no annotations, no output schema, and no parameter descriptions, the description is far too thin. An agent cannot tell what scope project_id imposes or what the explanation returns.

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%, yet the description never mentions event_id or the optional project_id, so neither parameter's meaning or format is clarified anywhere. The description fails to compensate for 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 states a clear verb ('explain') and a specific resource ('weight calculation of a single event'), which is more precise than a tautology. It does not, however, differentiate itself from the sibling compute_weights, which likely computes the same quantity.

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 call this versus compute_weights or any other sibling, and no prerequisites or preconditions are stated. The agent must infer solely from the word 'explain'.

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 and falls far short. It does not say where the export goes, what format is emitted, whether the operation writes files or has side effects, or whether the adapter value must come from list_export_adapters. Only the bare mechanism (an adapter is involved) is conveyed.

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?

It is a single grammatical sentence with zero filler, which is structurally clean. But at nine characters of content it reads as under-specification rather than conciseness, so it earns only a middling score.

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 three parameters at 0% schema coverage, no annotations, no output schema, and a nested options object, the description supplies almost none of what an agent needs. It omits adapter discovery, output location/format, and any behavioral caveats, leaving the caller unable to invoke it correctly without trial and error.

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% across three parameters, including a free-form nested `options` object with additionalProperties and a required `adapter` string. The description mentions the adapter concept but gives no expected values, no relationship to list_export_adapters, and no hint about what `options` accepts or what `project_id` scopes. The schema gap is entirely unmitigated.

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 verb (export) and a resource (narrative data) plus a mechanism (via adapter), so the basic action is identifiable. However, "narrative data" is vague about scope, and the description does nothing to distinguish this from the related sibling list_export_adapters or to say what is actually produced. Adequate but not sharp.

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, what prerequisites exist, or which sibling to consult first. The presence of list_export_adapters strongly implies the agent must discover a valid adapter value beforehand, and the description never makes that connection. Nothing is misleading, but nothing is offered either.

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 behavioral burden, yet it discloses nothing. An agent cannot tell whether this mutates stored data, whether it requires an existing template, whether existing content is overwritten, or what permissions are 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?

It is a single short phrase, so nothing is bloated, but this reflects under-specification rather than conciseness. There is no front-loaded statement of purpose, behavior, or parameters to earn 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 four-parameter mutation tool with no annotations, no output schema, and zero schema coverage, the definition is completely inadequate. Nothing tells the agent what the tool returns or how to call it correctly.

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% across four parameters (id, theme, title, project_id), and the description mentions none of them. The agent must guess the meaning of each field, particularly theme versus title, with no compensating text.

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?

"填充事件写作模板" translates to "fill event writing template," which merely restates the tool name fill_event_template. It does not distinguish this tool from siblings like register_event or link_event_to_scene, nor does it clarify what "filling" a template means in practice.

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 such as register_event, update_event, or link_event_to_scene. No prerequisites, no exclusions, no context of any kind.

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 behavioral burden, yet it discloses nothing: not whether variants are persisted or ephemeral, whether this is a read or write operation, or how the required base_event and count interact. The description adds no behavioral context at all.

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 short phrase is technically concise but is under-specified rather than efficient: it omits the information a caller needs instead of trimming redundancy. Brevity here does not earn its place because it carries almost no content.

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 three-parameter tool with a nested required object, no annotations, no output schema, and 0% schema coverage, the description is far too thin. An agent has no way to know what a variant is, what count defaults to, or what the tool returns.

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% across three parameters, including a nested base_event object with id/title/weight and a count field. The description supplies no meaning for any parameter, leaving count, project_id, and the nested weight entirely undocumented.

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 phrase '基于事件生成变体' does state a verb (generate) and resource (variants) plus an input (an event), so the basic purpose is inferable. However it does not distinguish this from siblings like register_event, simulate_run, or suggest_beat, and 'variants' of what (event weights, narrative branches, text?) is ambiguous. Minimum-viable clarity with clear gaps.

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 versus the many variant/branch/simulation siblings, no prerequisites, no mention of the required base_event or project context. The agent must infer everything from the tool name alone.

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

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

No annotations are provided, so the description carries the full behavioral burden, and it says almost nothing. '获取' implies a read, but there is no disclosure of permissions, whether missing IDs fall back to project-level state, or what the returned knowledge-state structure 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?

A single front-loaded sentence with zero padding, which is efficient. However, the brevity here reflects under-specification rather than disciplined conciseness, since the sentence does not carry the weight a 3-parameter, un-annotated tool requires.

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?

With no annotations, no output schema, three undocumented-and-optional parameters, and an undefined result shape for 'knowledge state', the definition leaves too much for the agent to infer. It is inadequate for a query tool whose scope depends on how the three IDs interact.

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 names no parameters. It gestures at scene/event concepts, but project_id is never mentioned, and the relationship between the two optional filters (event_id vs scene_id, both non-required) — whether they are alternatives or combined — is left entirely unresolved.

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 (获取/get) and resource (玩家已知事实 – player-known facts), scoped by the moment of reaching a scene/event. It is clearly interpretable, but it offers no differentiation from adjacent siblings like check_knowledge or check_canon, which an agent could easily confuse with it.

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 when-to-use, when-not-to-use, or alternative-tool guidance. The phrase '到达某场景/事件时' describes the semantics of the result rather than the conditions under which an agent should choose this tool over check_knowledge or simulate_run.

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 does disclose that the tool reads configuration and capability switches (implying a non-destructive read), but says nothing about permissions, side effects on the active project, or the shape of what is returned. For a simple single-parameter read this is adequate but thin.

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 phrase with zero filler. It is efficient, though its brevity edges toward under-specification rather than pure 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?

The tool is simple (one optional, fully documented parameter) and the schema covers the input completely, but with no output schema the description should say more about what 'configuration and capability switches' are returned. It is minimally viable rather than 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 100%, so the schema already documents project_id and its NARRATIVE_DEFAULT_PROJECT fallback. The description adds no syntax, format, or constraint detail beyond the schema, which is the expected baseline when structured fields do the heavy lifting.

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 (项目配置与能力开关/project configuration and capability flags), which is more than a tautology of the name. However, it does not differentiate this tool from siblings like list_projects, discover_projects, or validate_project, which an agent must distinguish between.

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 when-to-use guidance, no statement of prerequisites, and no named alternative among the many project-related siblings. The agent is left to infer that this retrieves configuration rather than listing, validating, or initializing projects.

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?

Without annotations, the description must carry the full behavioral burden. It says it resolves the active project and returns resources and a summary, but doesn't disclose whether it mutates state (it seems read-only), what 'Resources' are, what the summary contains, or the output format. No permissions, rate limits, or side effects are mentioned.

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, efficient sentence with no waste, front-loaded with the action. It is appropriately sized, though the brevity contributes to the lack of detail.

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 that apparently resolves project context and returns multiple artifacts, the description is too sparse. With no annotations, no output schema, and no explanation of what '写作前必读 Resources' or the summary entail, an agent lacks sufficient information to use it correctly.

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 100%, with project_id fully described ('省略则自动发现'). The description adds nothing about the parameter beyond what the schema already states, so the 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 states a specific verb+resource ('解析活动项目' and '返回...Resources 与摘要'), which is more specific than a tautology. But it doesn't differentiate itself from siblings like get_project or discover_projects, and the notion of '写作前必读 Resources' is unusual and undefined, leaving the exact purpose somewhat vague.

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. It doesn't explain when to provide project_id (vs. auto-discovery), or how it relates to get_project, discover_projects, or set_active_project. The only hint is in the schema parameter description, not the tool 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?

No annotations are provided, so the description carries the full burden of behavioral disclosure. It only says that a `.narrative/` directory is initialized, without stating whether existing content is overwritten, what permissions or side effects apply, or what the tool returns. For an initialization/mutation tool, this leaves important behavior opaque.

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 with no wasted words. It is concise and easy to parse, though its extreme brevity contributes to the broader completeness gaps rather than being a structural flaw in itself.

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 initialization tool with five parameters, no annotations, and no output schema, the description is too sparse. It does not explain project identity requirements, directory initialization side effects, relationship to other project-management siblings, or what happens after initialization.

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 only 60%, and the description does not explain any of the five parameters. It adds no meaning beyond the schema for required fields like `id` and `title`, or for less obvious parameters such as `scopes_in_use` and `capability_preset`, which are not described in the schema either.

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: initialize a game narrative project directory, specifically `.narrative/`. It is understandable without opening the schema. However, it does not distinguish this from sibling tools such as `init_workspace`, `set_active_project`, or `list_projects`, which may overlap in project setup/management.

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, nor does it state prerequisites such as whether a project ID must be unique or whether an existing directory will be overwritten. Sibling tools like `init_workspace` make explicit usage guidance especially important.

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 the created paths and that a Cursor config snippet is returned, but says nothing about idempotency, whether existing files are overwritten, permissions, or side effects of setting .active-project.

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 redundant clauses; the action and its outputs are stated up front. It is efficient, though very terse for a six-parameter mutation 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 that creates a directory tree, sets an active project, and returns a config snippet, with no annotations and no output schema, the description is thin. It omits idempotency, overwrite behavior, and how it differs from init_project, leaving key decisions to inference.

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 83% (high), so the schema documents most parameters. The description adds no parameter-level meaning beyond what the schema already provides, matching the baseline 3 for high 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?

States a specific verb (初始化/initialize) and concrete resources (narrative/projects/{id}/.narrative/, .active-project, Cursor config snippet). An agent can tell roughly what the tool produces, but there is no differentiation from the sibling init_project, so it falls short of a 5.

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 only states what happens; it gives no when-to-use context, no prerequisites, and does not distinguish this from init_project or set_active_project. The agent must infer usage entirely.

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 behavioral burden, and it discloses nothing. It does not say whether this creates or mutates a relationship, whether it is idempotent, what permissions are needed, or what happens if the beat/thread/curve do not exist.

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?

It is a single short, front-loaded phrase with no padding, which is structurally fine. But it largely duplicates the tool name and title, so it does not really earn its place beyond them.

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?

This is a mutation-style linking tool with four undocumented parameters, no annotations, and no output schema, and the description supplies none of the missing context. An agent has almost nothing to go on beyond the literal name.

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% across four parameters (curve_id, beat_id, thread_id, project_id), and the description adds no meaning for any of them. In particular it never explains the role of curve_id, the optional project_id, or the expected ID formats.

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 phrase 'link beat to thread' names a verb and two resources, so the basic operation is discernible. However, it essentially restates the tool name (and the title), adding only the clarification that 'thread' means a foreshadowing thread (伏笔线程). It gives no differentiation from siblings such as link_event_to_scene or connect_nodes.

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 when-to-use, when-not-to-use, prerequisite, or alternative guidance at all. An agent cannot tell from this description when linking a beat to a thread is appropriate versus registering a thread or advancing a thread phase.

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, yet it discloses nothing: not whether linking is idempotent, whether it mutates or replaces an existing link, whether it requires an active project, or what side effects occur. For a mutation tool with zero annotation coverage this is a complete 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?

At a single terse clause it is not verbose, but this is under-specification rather than conciseness. There is no front-loaded context, no scope, no constraints, and no routing information an agent could use.

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?

With no annotations, no output schema, 0% parameter documentation, and three parameters, the description is far too thin for an agent to invoke this tool confidently. It should at minimum state the linking semantics, the role of project_id, and how it differs from sibling linking 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?

Schema description coverage is 0% and there are 3 parameters, so the description must compensate. It implicitly covers two of them (event_id, scene_id) via the phrase 'link event to scene', but the optional project_id is entirely unexplained, as are the ID formats and whether project_id is required for scoping.

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 phrase 'link event to scene' states a specific verb (link) and both resources (event, scene), so an agent can infer the operation. However, it offers no differentiation from similarly named siblings such as link_beat_to_thread, connect_nodes, or register_event, leaving the agent to open schemas to disambiguate.

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 statement of when this tool should be used versus alternatives like link_beat_to_thread or register_relationship, nor any prerequisite (e.g., must the scene and event already exist, must a project be active). Usage is only implied by the name.

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 doesn't disclose any behavioral traits beyond the implied read-only nature—no information on ordering, pagination, or what the adapters represent, and it doesn't clarify return format despite having no output 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?

A single clear, front-loaded phrase with no wasted words. It's appropriately sized for a simple listing 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 parameterless read-only tool, the description is minimally complete: it tells the agent what the tool does at a high level. However, with no output schema and no annotations, it doesn't explain return shape, ordering, or how adapters relate to export operations, leaving gaps an agent would notice.

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 takes zero parameters, so this dimension uses the 0-param baseline of 4. There are no parameters whose semantics need explaining, and the schema is empty.

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+resource (list export adapters), which is clear on its own. The description is a single direct phrase, but it offers no differentiation from the vast set of sibling tools, many of which also 'list' resources (list_projects, list_scenes).

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 such as the 'export' sibling or other listing tools. The purpose is implied but the description provides no 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.

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 of behavioral disclosure. It says nothing about whether this is a read-only operation, whether it includes archived projects, whether results are paginated or sorted, or what the output format looks like. For a list operation with zero annotation coverage, these gaps matter.

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 with no wasted words. It is front-loaded and to the point. For a zero-parameter list tool, this is appropriately sized.

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?

With no annotations and no output schema, the description should provide more context about the behavior and result of listing projects. It is missing information about ordering, scope, or filtering. Given the surrounding suite of project tools, more guidance on its role is needed for an agent to use it correctly among siblings.

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?

Parameter count is 0, so the baseline is 4 per the rubric. There are no parameters to document, and the description does not need to explain any. No additional parameter semantics are applicable.

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 action and resource ('列出所有叙事项目' = list all narrative projects), which is clear enough on its own. However, it does nothing to distinguish itself from sibling tools like discover_projects, get_project, or set_active_project, which all interact with projects. No sibling differentiation is present.

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 offers no guidance on when to use this tool versus the many sibling project-related tools (discover_projects, get_project, validate_project, set_active_project). There are no exclusions, prerequisites, or alternative recommendations. Usage is only implied by the tool name.

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 behavioral burden, and it discloses nothing: no permission requirements, no pagination or ordering behavior, no statement of whether an empty result is possible, and no indication of the relationship to project scoping.

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 definition is a single short phrase with zero padding, which is appropriately front-loaded, but this brevity is achieved by omitting necessary information rather than by efficient writing.

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?

With no output schema, no annotations, and an undocumented optional parameter, the description is too thin for an agent to call the tool correctly. It should at minimum explain the project_id scoping behavior and the shape of the returned scene list.

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% for the single project_id parameter, and the description says nothing about it — whether it is required, what happens if omitted (all projects?), or what form the identifier takes. The description therefore fails to compensate for the undocumented 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 Chinese phrase '列出场景注册表' gives a clear verb (列出/list) and resource (场景注册表/scene registry), so the basic purpose is understandable. However, it adds no scope, filtering, or distinguishing detail versus siblings like register_scene or link_event_to_scene, leaving differentiation to the agent's inference.

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 such as register_scene or get_project. The only implied usage is the bare notion of 'listing', which the agent must reconstruct on its own.

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 says nothing about whether this is a read or mutation operation, what side effects occur, what permissions are required, or what the result represents.

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 its brevity reflects under-specification rather than conciseness. There is no structure or front-loaded information to help an agent understand the tool's purpose.

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?

With no annotations, no output schema, 0% schema description coverage, and a complex domain of sibling tools around endings and branching, the description is far too incomplete. It leaves the agent unable to determine what the tool does or how to invoke it correctly.

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 one parameter, project_id, with 0% description coverage, and the description does not mention it at all. With low coverage, the description should compensate, but it provides no meaning for the parameter or its expected format.

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 '映射结局空间与空洞' essentially restates the tool name and title, adding only an unclear notion of '空洞' (holes/void). It does not explain what mapping an ending space entails or how it differs from siblings like compare_endings or register_ending_axis.

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, what preconditions must be met, or which alternatives are appropriate. The description provides no context about its role in the larger ending/validation workflow.

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 implies a mutation ('添加或更新', add or update) but says nothing about permissions, whether an existing beat is overwritten, validation rules, or side effects. This is only a slight step above no behavioral information.

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 single sentence is front-loaded and free of filler, so it is structurally clean. However, it is under-sized for a tool with a nested object schema and many sibling operations, making it minimally adequate rather than well-calibrated.

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 complex nested beat object, 3 parameters, no annotations, and 0% schema description coverage, the description leaves major gaps. It does not explain required beat fields, how updates are matched, or how this tool relates to the many beat/sibling tools in the environment.

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 adds no parameter meaning beyond naming the conceptual targets. It does not explain curve_id, project_id, or the nested beat object's required fields (id, depth, label) or optional fields such as type, emotion, scene_id, and thread_ids. For a nested-object tool with zero schema coverage, this is inadequate.

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 ('添加或更新', add or update) and resource ('节拍', beat) plus the target ('节奏曲线', rhythm curve), so an agent knows it writes into a pacing curve. It does not distinguish itself from siblings such as suggest_beat, create_beat_sheet, or register_event, so it falls short of a 5.

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 when-to-use guidance or comparison to alternatives. The agent is not told whether this is for manually registering a beat versus using suggest_beat/suggest_next_beat, nor what conditions require an update rather than an insert.

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, and it discloses nothing. It does not state whether the node is persisted, what happens on duplicate ids, whether the graph must exist first, or what permissions are needed. For a mutation tool with 9 parameters and zero annotation coverage, this is a complete 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?

It is short, but this is under-specification rather than conciseness — a single six-character phrase that earns nothing. There is no front-loaded explanation because there is no explanation at all.

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?

A 9-parameter graph-construction mutation tool with no annotations, no output schema, and 0% schema coverage demands substantial description, and none is given. The description is also written in Chinese while the tool name, title, and all sibling names are English, creating an avoidable language mismatch for the calling 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% across 9 parameters, and the description adds no parameter meaning whatsoever. Critical fields such as exits, is_convergence, convergence_group, depth, and is_terminal are entirely unexplained, so an agent cannot know how to populate them.

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 '注册分支图节点' is a direct restatement of the tool name and title ('Register Branch Node'), adding no distinguishing detail. It conveys a verb+resource but nothing an agent couldn't infer from the name alone, and it does not separate this tool from close siblings like connect_branch, add_branch_edge, or register_event.

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 when-to-use guidance, no prerequisites, and no mention of alternatives. With siblings such as connect_nodes, validate_branch_graph, connect_branch, and add_branch_edge, an agent has no basis for choosing this tool over them.

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 supplied, so the description carries the full burden, and it discloses nothing about behavior. It does not say whether this creates or overwrites an arc, what scope semantics mean, whether related entities must pre-exist, or what happens on conflict.

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?

It is short and front-loaded, but that brevity reflects under-specification rather than efficiency. A single duplicated title phrase cannot earn its place as the whole 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?

For a 6-parameter mutation tool with a nested points array, an enum-constrained scope, no annotations, and no output schema, the description is completely inadequate. An agent cannot correctly construct a call from this.

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?

Six parameters with 0% schema description coverage, and the description adds no meaning for any of them. The nested points array (with order, emotion -10..10, trait, beat_id, event_id, scene_id) and the scope enum are entirely undocumented.

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 is a literal translation of the tool title ('注册角色情感弧光' = 'Register Character Arc'), so it restates rather than clarifies. It names a verb and resource but offers no scope, no distinguishing detail from siblings like analyze_character_arc or scaffold_minimal_arc.

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 when-to-use, when-not-to-use, or alternative guidance is provided. An agent has no signal on when registration is expected versus analysis (analyze_character_arc) or scaffolding (scaffold_minimal_arc).

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 behavioral burden. It does not disclose side effects, persistence behavior, validation rules, conflict handling, permissions, or what registration actually changes in the system.

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 phrase, so it avoids bloat, but it is under-specified rather than appropriately concise. It lacks the structure needed to communicate purpose, usage, or behavior for a 7-parameter 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?

With no annotations, no output schema, 0% schema description coverage, and seven parameters, the description is completely inadequate. An agent would need to infer nearly everything about safe and correct invocation from the bare schema alone.

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 mentions only 'mutex / requires', which is already fully specified by the schema enum. Six other parameters (id, items, scope, source, target, project_id) receive no explanation whatsoever, leaving critical semantics undocumented.

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+resource ('注册 ... 约束') and names the two constraint types ('mutex / requires'). It is clear what the tool broadly does, but it does not differentiate this tool from the many other register_* siblings.

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, nor any prerequisites or context for choosing between mutex and requires. The description only states what is registered, leaving all usage conditions 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?

With no annotations, the description carries the full burden. It does disclose upsert semantics ('注册或更新'), which is useful, but says nothing about whether an invocation replaces the whole ruleset or merges into existing rules, what happens to omitted sections, whether permissions or an active project are required, or that this is a mutation. For a write tool with nested configuration objects, that is a significant 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?

A single tight sentence with the key action front-loaded and the three domains in parentheses as an efficient scannable summary. It is not padded, though the terseness is partly under-specification rather than disciplined concision.

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 four-parameter nested-object mutation with no annotations, no output schema, and zero schema descriptions, the description is too thin. An agent cannot determine merge-vs-replace behavior, required context, or the meaning of most fields from this alone.

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% across four parameters, two of which are nested objects with enums (formality, humor_level, allow_ai_on_status). The description names three of the four parameter domains but adds no meaning about allowed values, interaction between sections, or the role of project_id, which is entirely unmentioned.

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 pair (注册/更新) and the resource (项目内容圣经) plus the three domains it governs (基调/合规/草稿策略), which map to the top-level schema keys. It is distinguishable from the crowded register_* family (register_entity, register_fact, register_flag) by naming content rules specifically, though it never contrasts itself with the closest sibling check_scene_against_rules, which consumes exactly this data.

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 when-to-use framing, no prerequisites, and no mention of alternatives. In a project where check_scene_against_rules and validate_project depend on these rules, the agent gets no hint about when these rules must be in place or whether they are required before other operations.

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 and the description says nothing about what gets created or modified, what resolve_when semantics mean, thread phase interactions, or side effects on project state. For a mutation tool registering ending conditions, this leaves the agent blind.

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?

It is very short and front-loaded, but brevity here reflects under-specification rather than effective conciseness. No wasted words, but nothing earns its place either.

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 9-parameter mutation tool with nested objects, zero schema description coverage, no annotations, and no output schema, the description is completely inadequate. It provides no semantic context needed to call this tool correctly.

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% across 9 parameters including nested objects (min_axis, requires_flags) and an enum (resolve_when), yet the description provides no parameter meaning. This is a severe gap that the one-line description does nothing to address.

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 merely restates the tool name in Chinese ("注册结局条件" = "register ending condition"), which is a tautology rather than a specific statement of what the tool does. It doesn't distinguish from siblings like compare_endings, register_ending_axis, or map_ending_space, nor does it explain that it creates/persists an ending condition definition.

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 is provided. With ~60 sibling tools including compare_endings, register_ending_axis, and map_ending_space, an agent would need to guess entirely.

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 behavioral burden — and it discloses nothing. It does not say what an 'ending axis' is, whether registration is idempotent, what happens on ID collision, or what permissions/state it requires. For a mutation-style 'register' tool with zero annotation coverage, this is a complete 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 single short phrase wastes no words, but this is under-specification rather than conciseness. A one-line restatement of the title cannot be considered appropriately structured for a 7-parameter 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 7 parameters at 0% schema coverage, no annotations, and no output schema, the description should explain the tool's role in the ending/vector model. Instead it provides nothing an agent can act on beyond the name.

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% across 7 parameters (id, name, scope, min, max, default, project_id), and the description adds no meaning for any of them. Critical ambiguity — e.g. what 'scope' values ('run','meta','campaign','global','slot') imply, or how min/max/default interact — is left entirely undocumented.

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 "注册结局向量轴" is essentially a Chinese restatement of the tool name register_ending_axis — no additional verb, resource scope, or distinguishing detail. It does not differentiate this from siblings like register_ending, map_ending_space, or compare_endings. This is tautological rather than clarifying.

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 vs the many closely related siblings (register_ending, register_character_arc, map_ending_space, compare_endings). No prerequisites, ordering, or exclusion conditions are stated.

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 behavioral burden. It implies a mutation ('注册' / register) but says nothing about permissions, duplicate handling, idempotency, or whether the entity affects downstream canon checks, which is significant for a registration 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?

A single front-loaded sentence with no padding. It is efficient but borders on under-specification rather than being genuinely well-structured for the tool's complexity.

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?

A 6-parameter mutation tool with no annotations, no output schema, and 0% schema coverage needs more than one short sentence. The description omits parameter meanings, behavior, and disambiguation from the register_* family, leaving the agent under-informed.

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 there are 6 parameters, so the description must compensate. It loosely names three of the five enum values for 'type' (character/location/item) but omits faction/other and gives no meaning to id, name, tags, project_id, or description.

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 (register) and resource (canon entity) with illustrative subtypes (character/location/item). It does not differentiate this tool from the many register_* siblings such as register_fact, register_glossary_term, or register_character_arc, so an agent cannot easily tell which registry to target.

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 when-to-use guidance, no prerequisite context, and no mention of alternatives. With siblings like register_fact and register_glossary_term, the agent has no signal for choosing register_entity over them.

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, and it supplies none. It does not say whether this mutates state, what is created, whether the operation is idempotent, what permissions are needed, or what happens on duplicate ids.

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 characters is not conciseness but under-specification; the text is too short to be front-loaded with anything. There is no waste, but also no content to earn 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?

A 10-parameter mutation tool with no annotations, no output schema, and 0% schema coverage needs the description to do nearly all the explanatory work. It does none of it, leaving the agent unable to construct a valid or meaningful call.

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?

Ten parameters with 0% schema description coverage and zero parameter information in the description. Required id/title versus optional text, depth, weight, assumes, reveals, pool_tags, project_id, and exclusion_group are all completely undocumented in every source.

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 '注册叙事事件' merely restates the tool name and title ('Register Event') with the domain noun 'narrative' added. It conveys no distinguishing detail against the many sibling register_* tools (register_beat, register_scene, register_thread, register_fact). An agent cannot tell when a 'narrative event' differs from a beat, scene, or fact.

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 when-to-use guidance, no prerequisites, and no mention of any alternative. With ~60 siblings including update_event, register_beat, and link_event_to_scene, the absence of routing guidance is a serious gap.

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 behavioral burden, yet it discloses nothing beyond the name — no idempotency/duplicate handling, no validation against existing canon, no permission requirements, and no effect of the scope fields. For a canon-mutating registration tool this is a complete 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?

It is a single short phrase with no wasted words, but this reflects severe under-specification rather than effective conciseness. There is no front-loaded explanation of what a 'fact' is or how it differs from a sibling registration.

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 6-parameter canon-registration tool with no annotations and no output schema, a nine-character phrase is far too thin. An agent cannot determine required behavioral semantics, scope meaning, or return expectations from what is given.

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?

Six parameters exist with 0% schema description coverage, and the description explains none of them. Critically, the scope and player_knowledge_scope enums (run/meta/campaign/global/slot) carry meaning the description never disambiguates, and required id/statement semantics are undocumented.

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 phrase '注册客观事实（canon）' conveys a verb (register) and a resource (objective fact/canon), so the basic purpose is inferable. However, it does not distinguish this tool from the many register_* siblings (register_entity, register_event, register_flag, register_relationship) nor from check_canon, which shares the 'canon' concept, leaving the boundary ambiguous.

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 such as check_canon or the other register_* tools, and no preconditions are stated. The only usage signal is implicit in the word 'canon'.

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 behavioral burden, and it largely fails: only the word 'declarative' hints at declaration/idempotent semantics. It says nothing about scope precedence, overwrite behavior on duplicate ids, required permissions, or what happens on conflict.

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?

It is short, but this is under-specification rather than earned conciseness; there is no front-loaded statement of operation, effect, or constraint. The single fragment does not function as a usable 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?

For a 5-parameter, non-trivial registration tool with no annotations and no output schema, the description supplies essentially nothing. Critical unknowns such as the scope hierarchy and duplicate-id behavior are left completely undocumented.

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% with 5 parameters, and the text adds no meaning for any of them. It names 'flag' and 'scope' vaguely but never explains id format, the meaning of run/meta/campaign/global/slot, the role of 'default', or project_id, so the enum-heavy scope parameter is left entirely 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 '声明式 flag 及 scope' ('declarative flag and scope') is close to a restatement of the tool name and only gestures at the resource. It never states a verb like 'register/declare' explicitly nor distinguishes this from the many other register_* siblings (register_event, register_entity, register_thread, 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?

There is no when-to-use guidance, no prerequisites, and no mention of alternatives among the ~60 sibling tools. An agent cannot infer from the text when this flag registration should be preferred over register_constraint or register_content_rules.

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 entire burden — and it discloses nothing. For a write/registration tool with 8 parameters and no safety profile, the absence of any statement about persistence, scope semantics, side effects, or validation behavior is a severe 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?

It is short, but the brevity is under-specification rather than conciseness — a single alias phrase where a full definition is needed. There is no structure to front-load because nothing substantive is stated.

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 8 undocumented parameters, no annotations, no output schema, and nested phase objects with their own enums, the definition is nowhere near complete enough for an agent to invoke it correctly.

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% across 8 parameters (including three enums: scope, status/phase status, visibility). The description supplies no meaning for any of them, not even for the required id/title/phases trio.

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 only identifies the tool as an alias of register_thread and restates the name in Chinese ('登记伏笔线程'), so the operation is inferable but never described in terms of what it actually does. It does provide one genuinely useful routing signal — that this is the same operation as register_thread — which is more than a pure tautology.

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 alias note weakly implies 'use this as an equivalent to register_thread', but there is no explicit when-to-use, when-not-to-use, or preference between the two identically-behaving tools. An agent still has to guess whether to call this or register_thread.

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, and it discloses nothing. For a mutating registration tool, there is no mention of idempotency, duplicate-id handling, permission requirements, persistence scope (project vs global), or side effects.

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

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

The single phrase is short, but this is under-specification rather than conciseness — it contains no information beyond the tool name. There is no structure or front-loaded guidance to evaluate.

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 5-parameter mutation tool with no annotations, no output schema, and 0% schema description coverage, the description is completely inadequate. An agent has no basis to decide when to call it or how to populate the required id/canonical pair correctly.

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 adds nothing about the 5 parameters. Critical ambiguities are unresolved: what 'id' vs 'canonical' means, whether aliases replace or append, and what 'project_id' scoping implies when omitted.

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 '注册专有名词表条目' merely restates the tool name 'register_glossary_term' / title 'Register Glossary Term' in Chinese. It names no distinguishing scope, target resource semantics, or differentiating factor from the many sibling register_* tools (register_entity, register_fact, register_flag, register_event, register_constraint, 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?

There is no when-to-use, when-not-to-use, prerequisite, or alternative-tool guidance at all. With over 50 sibling tools including several near-identical register_* verbs, the absence of any routing guidance is a serious gap.

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 behavioral burden, yet it says nothing about idempotency of 'id', behavior on duplicate registration, required project context, or whether the rule applies globally or per-locale. Only the bare verb 'register' hints at a mutating operation.

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 single short phrase is not padded, but it is under-specified rather than concise: it omits everything an agent would need to call the tool correctly. Brevity here reflects incompleteness, not economy.

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 5-parameter mutation tool with no annotations and no output schema, the description is far too thin. Nothing about required inputs, the effect of registering a constraint, or return behavior is conveyed.

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 5 parameters with 0% schema description coverage, and the description mentions none of them. The meanings of 'id', 'field', 'locale', 'max_length', and 'project_id' must be inferred entirely from their names, which is especially risky for 'id' and 'field'.

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 gives a specific verb and resource ('register' + 'localization text constraint'), which is enough to know a rule is being created. However, it largely restates the tool name/title and does not distinguish it from neighbors like register_constraint or check_localization, leaving scope ambiguous.

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 such as register_constraint, register_content_rules, or check_localization. No preconditions, no exclusions, not even an implied workflow context 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?

No annotations are provided, so the description carries the full burden, yet it discloses nothing about mutation semantics, persistence, side effects, or validation behavior. An agent cannot tell what this operation actually does beyond its name.

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 text is short, but this is under-specification rather than conciseness — a four-character phrase that omits everything an agent needs. Nothing is front-loaded because nothing is provided.

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?

A six-parameter mutation tool with no annotations, no output schema, and no parameter documentation has effectively no specification. The description is completely inadequate 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?

Six parameters with 0% schema description coverage, and the description mentions none of them. The meanings of id, name, event_ids, min_events, project_id, and tags are entirely undocumented.

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 '注册事件池' merely restates the tool name register_pool in Chinese, giving no information an agent couldn't derive from the identifier itself. It does not distinguish this tool from siblings like check_pool_health or register_event.

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 indication of when to register a pool, what prerequisites exist, or how it relates to sibling tools such as check_pool_health or register_event. No guidance at all.

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 behavioral burden, and it discloses nothing: not whether this mutates persistent state, what happens on duplicate id, whether relationships are reversible or can be removed, or what '跨局' (cross-run) implies for scope behavior. For a mutation tool with zero annotation coverage, this is a major 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?

Extremely short – a single phrase – but this is under-specification rather than conciseness. There's no front-loaded structure because there is essentially no content to 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?

For a 5-parameter mutation tool with no annotations, no output schema, and 0% schema description coverage, the definition provides almost nothing. The description is completely inadequate for calling this tool correctly.

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 all 5 parameters, and it documents none. The description mentions no parameter at all – not id, entity_id, scope, affinity, or project_id. An agent cannot infer that 'id' is the relationship identifier, 'scope' controls the enum of run/meta/campaign/global/slot, or that 'affinity' is a numeric weight.

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 '注册 NPC 跨局关系' restates the tool name with minimal added specificity – it says to register a cross-run NPC relationship, but doesn't clarify what a 'relationship' means (affinity score? scope?), how it differs from register_entity/register_fact, or what data is captured. The title and name already convey this much. It's not a pure tautology, but it falls short of naming a specific verb+resource distinction.

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 when-to-use guidance at all. With many sibling registration tools (register_entity, register_fact, register_event, register_character_arc), an agent has no way to know when to call this versus those. The description contains zero usage 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 carries the full behavioral burden, and it discloses nothing: not whether registering creates or upserts, what happens on duplicate id, whether the 8 optional parameters are persisted as-is, or what permissions/active-project state are required. The verb implies a mutation but no consequences are described.

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?

It is short and front-loaded, but this is under-specification rather than conciseness: a single seven-character phrase cannot carry a 10-parameter mutation tool. No sentence is wasted, but far too few sentences exist.

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 10-parameter creation tool with no annotations, no output schema, and 0% schema coverage, the description is completely inadequate. Nothing about required fields beyond the schema's implicit required list, relationships to projects/beats/threads, or failure behavior is communicated.

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 adds no parameter meaning at all for a tool with 10 parameters (id, act, depth, title, status, beat_id, quest_id, event_ids, project_id, thread_ids). An agent cannot tell, for example, whether depth is an ordering index or a narrative-depth metric, or what event_ids/thread_ids reference.

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 verb+resource ('注册' / register) but the resource is given as an ambiguous compound '场景/任务清单条目' (scene/task-list entry), which leaves it unclear whether this registers a narrative scene, a quest-list row, or a generic scene record. It does nothing to distinguish it from siblings like list_scenes, link_event_to_scene, or check_scene_against_rules.

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, when not to, or which sibling (e.g. register_event, register_beat, link_event_to_scene) is the alternative. The agent is left to infer usage entirely from the name.

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, yet it says nothing about persistence, idempotency, required permissions, side effects, or what happens when phase/depends_on references do not resolve. The word '注册' implies a mutation but no consequences are described.

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?

It is short, but this is under-specification rather than conciseness; a single noun-phrase fragment provides no structure an agent can act on. Nothing is front-loaded because there is effectively no content.

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, nested objects, three enums, no annotations, and no output schema, the description is wholly inadequate. An agent has no way to construct a valid phases array or understand thread lifecycle semantics from this text.

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% across 9 parameters, including nested phase objects and three enum-bearing fields. The description adds no meaning for id, scope, phases, status, current_phase, depends_on, or visibility, leaving an agent unable to interpret the required phases structure.

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 '注册 Meta 伏笔线程' (register Meta foreshadowing thread) only marginally extends the name/title by adding the qualifier 'Meta' and the word '伏笔' (foreshadowing). It does not distinguish this tool from siblings like register_foreshadowing, advance_thread_phase, or check_thread_health, and the meaning of the 'Meta' scope is left undefined.

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 the many thread-related siblings (register_foreshadowing, link_beat_to_thread, check_thread_health, advance_thread_phase). No prerequisites, ordering, or exclusion conditions are stated.

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 behavioral burden, and it discloses nothing. It does not say whether registration is idempotent, whether it errors on duplicates, whether ordering constraints (must_follow) are validated at registration or later, or whether other graph state is mutated.

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?

It is short, but this is under-specification rather than conciseness. The single fragment conveys no actionable information and nothing is front-loaded because there is no substance to prioritize.

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 7 parameters, 2 required, 0% schema coverage, no annotations, and no output schema. A registration tool that likely participates in graph validation (see validate_branch_graph, check_timeline) needs to explain constraints and failure modes, and none are present.

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% across 7 parameters, and the description adds nothing about any of them. Critical semantics such as the meaning and uniqueness of 'id', the unit/ordering intent of 'order', and the relationship between 'event_id', 'scene_id', and 'project_id' are entirely undocumented.

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 is a tautology: '注册时间线/因果条目' restates the tool name and title ('Register Timeline Entry') without adding scope, verb nuance, or distinguishing it from the many other register_* siblings (register_beat, register_event, register_thread, register_entity). It does not clarify what a timeline/causal entry is versus those adjacent registrations.

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. Siblings like register_event, register_beat, and check_timeline are obvious confusers, yet nothing indicates when a timeline entry is required or what prerequisites exist (e.g., must the event/scene already be registered?).

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