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

Annotations indicate a write operation, and the description confirms adding a constraint. However, it lacks disclosure of behavioral traits such as overwrite behavior, limits, or permission requirements.

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 relatively concise and front-loaded with the main purpose, but uses mixed language (Japanese/English) which may reduce clarity. It could be more streamlined.

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

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

Given the 5 parameters, nested objects, and no output schema, the description covers the main templates adequately but omits return values, error cases, and the note/branch parameters. Sibling distinction is implicit rather than explicit.

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

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

The description explains the template parameter and its possible values in detail, and mentions scope, but does not cover branch, note, or params at the parameter level. With 0% schema coverage, this partial coverage is adequate but not complete.

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

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

The description explicitly states the tool adds a constraint (verb+resource) and lists four distinct templates with examples, clearly distinguishing from siblings like set_constraint or list_constraints.

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

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

Usage is implied through template descriptions and examples, but there is no explicit guidance on when to use this tool versus alternatives like set_constraint, nor any when-not conditions.

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

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

Annotations only provide readOnlyHint=false, so the description must disclose all behavioral traits. It extensively covers constraint checking with rejection, alias detection, temporal semantics (valid_to as open interval, supersession), and response formats (status, question_id). No contradictions with annotations.

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 quite long and dense, mixing examples and explanations in a stream-of-consciousness style. While information-rich, it lacks clear sectioning and could be more concise by separating parameter details from usage examples.

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

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

Given the complexity (9 parameters, no output schema), the description covers most aspects: temporal model, constraint checking, alias detection. However, it does not explicitly state the success return format (e.g., fact ID) and omits explanation for the required 'branch' parameter, leaving minor gaps.

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

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

Schema description coverage is 0%, so the description carries full burden. It explains all major parameters: chapter, valid_to, narrated_in, attribute, value, kind (with examples), subject, and num (via LEDGER). It adds critical meaning about temporal intervals and narrative timing that the schema lacks.

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

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

The description clearly states 'register one fact' (事実を1件登録) with specific verb and resource. It distinguishes from sibling add_facts by using '1件', implying singular operation. Examples of attributes and temporal parameters solidify the purpose.

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

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

The description provides usage context: basic operation when writing from scratch, and examples of when to use valid_to (e.g., death). It mentions link_entities as an alternative for proactive alias handling, but does not explicitly compare to add_facts or add_setup for batch versus singular usage.

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

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

The description reveals extensive behavioral traits beyond the annotations: it explains that each fact is gated with hard constraints, details the atomic parameter's effect on partial vs full rollback, and describes the return value format. The annotation only provides readOnlyHint=false, so the description adds substantial transparency.

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

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

The description is a single paragraph in Japanese, front-loaded with the main purpose. It uses a concise structure with inline examples and parameter explanations. It is not overly long, but the mixed language and lack of code-like formatting slightly reduce readability. Overall efficient.

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

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

Given the tool's complexity (multiple facts, atomicity, hard constraints, return values), the description covers key aspects but misses explaining the 'branch' parameter. There is no output schema, but the return format is described. The absence of output schema and incomplete parameter explanation leaves some gaps.

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

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

Schema coverage is 0%, so the description must compensate. It explains the structure of the 'facts' array and fields like subject, attribute, value, chapter, etc. It also explains the 'atomic' parameter. However, the required 'branch' parameter is not explained, leaving a gap. Thus, it adds value but is incomplete.

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

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

The description clearly states the tool registers multiple facts together with hard constraints, specifically for batch input of one scene's facts. The verb 'add_facts' is descriptive, and it distinguishes from sibling tools like 'add_fact' and 'add_constraint' by specifying bulk operation.

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

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

The description provides a specific use case: 'when you want to batch input facts for one scene.' It implies usage context but does not explicitly compare with similar tools like 'add_fact' or 'import_facts' or give when-not-to-use scenarios. The guidance is clear though not exhaustive.

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

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

Annotations indicate this is a write operation (readOnlyHint=false). The description adds behavioral context: it registers a setup, tracks overdue via 'payoff_by', and mentions the ledger metaphor. However, it doesn't explicitly state that a record is created or describe the return value, but the core behavior is clear.

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

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

The description is concise, front-loaded with the main purpose, and every sentence adds value. It uses a clear structure with parameter explanations embedded, no wasted words.

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

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

Given the 5 parameters and no output schema, the description covers the main usage well. It explains the purpose of each parameter and the overdue tracking. However, it does not describe the return value or success indication, which would be helpful. But overall it's fairly complete for a register tool.

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

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

Schema description coverage is 0%, but the description fully explains each parameter: 'setup' as the description of the setup, 'chapter' as where it is told, 'payoff_by' as optional deadline chapter with overdue display, and 'thread' as identifier. This adds significant meaning beyond the bare schema.

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

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

The description clearly states the verb 'register' ('登録する') and the resource 'foreshadowing/Chekhov's gun' ('伏線(チェーホフの銃)'), along with the purpose of tracking uncollected ones ('未回収を追跡する'). It distinguishes itself from the sibling tool 'resolve_setup' which closes setups.

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

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

The description provides explicit when-to-use guidance: register a setup. It mentions the alternative: close with 'resolve_setup' when collected. It also explains the meaning of parameters and how 'payoff_by' triggers overdue display in 'chapter_brief/open_setups', giving clear context.

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

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

The description mentions that the answer is persisted and reflected in consistency checks, and that for SOFT_CONTRADICTION there is no automatic operation. However, it does not fully disclose behavioral traits such as authorization needs, rate limits, or what 'determine the corresponding build operation' entails. The annotations only provide readOnlyHint=false, leaving the description to carry the burden, which it does inadequately.

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

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

The description is concise with several sentences, each addressing a specific scenario. It front-loads the main action and then enumerates cases. The structure is logical, though the use of Japanese and technical terms may reduce readability for an English-language agent. Still, it is efficient without fluff.

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 (handling multiple answer types with different effects) and the lack of output schema, the description is incomplete. It does not explain what 'build operation' means, what the return value is, or how the agent should interpret the result. The persistence and consistency implications are mentioned but not fully detailed.

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

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

The input schema provides only names and types (qid: integer, answer: string) with no descriptions. The description adds meaningful semantics for the 'answer' parameter by specifying possible values like 'identical' (for alias merge), 'src'/'dst' (for conflict resolution), and other values (for soft contradiction). However, the 'qid' parameter is not explained, leaving a 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 the tool answers a question and determines a build operation, but it is not explicit about what 'question' refers to. It details specific cases (ALIAS, MERGE_CONFLICT, SOFT_CONTRADICTION), which provide some clarity, but the overall purpose is somewhat vague without context from sibling tools like list_open_questions. The title is null, further reducing clarity.

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

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

No explicit guidance is given on when to use this tool versus alternatives. The description does not mention any prerequisites, context, or exclusions. It explains what the tool does in different scenarios but does not help an agent decide when to invoke it over siblings like add_fact or set_constraint.

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

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

Annotations already declare readOnlyHint=true. The description adds value by explaining the types of violations (hard vs soft) and that soft violations generate open questions. It also mentions auto-skip behavior. This adds useful behavioral context beyond the annotation.

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 relatively concise (4 lines) and front-loaded with purpose. However, it mixes Japanese and English, and could be more structured (e.g., list parameters). Still effective and not verbose.

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 3 parameters and no output schema, the description covers the core purpose and two parameters, but fails to explain 'as_of_chapter' or the return format (what violations look like). It provides use cases but lacks completeness for seamless invocation.

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

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

Schema coverage is 0%, so description must explain parameters. It explains 'branch' (entire branch) and 'include_soft' (enables semantic contradiction detection with NLI, auto-skip if model missing). However, 'as_of_chapter' is not explained, leaving a gap.

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

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

The description clearly states it audits the entire branch for deterministic and semantic contradictions. It distinguishes from siblings like 'check_constraints' (which checks constraints) and 'list_open_questions' (which lists questions, while this tool generates them). However, a more explicit distinction could improve clarity.

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

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

The description provides usage context: 'used for sanity check after import or after writing a chapter.' It also explains behavior when include_soft=True and model is unavailable (auto-skip), but lacks explicit when-not-to-use or comparison to alternatives.

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

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

Annotations declare readOnlyHint=true, and description confirms with '[read]'. Adds detailed behavioral context: return value structure, overdue setups, and purpose of reducing recall burden. No contradictions.

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?

Information is dense but mixed language (Japanese/English) and run-on structure. Could be more concise and better organized. Two sentences pack necessary info but at readability cost.

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

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

Given no output schema, description thoroughly explains the return value categories and their contents. Parameters are simple and defaults are clear. Adequate for an agent to invoke correctly, though parameter definitions could be more explicit.

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

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

Schema has 0% description coverage for parameters. Description mentions '第N章' linking to the chapter parameter and implies branch usage, but does not explicitly describe parameter roles or formats. Baseline 3 for missing coverage, with marginal added value.

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

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

Description states it is a read tool that bundles canon before writing a chapter, listing specific return categories (characters, world, constraints, etc.). Clearly distinguishes from siblings like get_state by describing its composite nature.

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

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

Explicitly says to call at the start of the writing loop to avoid multiple get_state calls, providing clear when-to-use and when-not-to-use guidance with an alternative named.

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

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

Annotations only provide readOnlyHint, suggesting no destructive actions. The description adds value by detailing the types of issues detected and the eager mode behavior, matching the read-only nature.

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

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

The description is concise and well-structured, with purpose first, then detection list, then eager mode. It avoids unnecessary words and is easy to parse.

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?

While it covers the tool's purpose and modes, it lacks explanation of the return value (beyond mentioning consistent) and the branch parameter remains unexplained, leaving gaps for an 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?

The eager parameter is well explained (auto-check on add_constraint vs explicit call), but the branch parameter is not described at all. With 0% schema coverage, the description compensates only partially.

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

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

The description clearly states the tool checks for structural contradictions and invalid settings in constraint sets, listing specific detection types. It distinguishes itself from sibling tools like add_constraint or list_constraints by focusing on validation.

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

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

The description provides context for on-demand vs delayed checking and explains the eager mode, but it does not explicitly state when to use this tool over alternatives or when not to use it.

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

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

Annotations only indicate a write operation (readOnlyHint=false). The description adds important behavioral context: no state copy occurs (only pointers) and the source of branching (current position or specific operation). This goes beyond the minimal annotations.

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

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

The description is concise (a few sentences) and front-loaded with purpose. The mix of Japanese and English may reduce clarity for some agents, but overall it efficiently conveys essential information without waste.

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

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

Given no output schema and minimal annotations, the description covers core functionality and key parameters. However, it omits details about return values, error conditions, and default behaviors (although defaults are in schema). It is reasonably complete but not exhaustive.

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

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

The description adds meaning to 'from_branch' and 'at_op' by stating they specify the source of branching. However, it does not describe the 'name' parameter beyond its existence. With 0% schema description coverage, the description partially compensates but is incomplete.

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

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

The description clearly states it creates a new branch and specifies use cases: parallel plots and if-expansion exploration. It also distinguishes from siblings by noting no state copying (only pointers). The verb 'create' and resource 'branch' are explicit.

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

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

The description provides explicit usage context: used for parallel plot exploration and if-expansion. It also explains branching from a specific position (from_branch or at_op). While it does not explicitly list when not to use, the context is clear enough among sibling tools.

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

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

Beyond the destructiveHint annotation, the description details what is deleted (pointers, unresolved questions, snapshots) and what remains (operation logs), plus the restriction on main, providing substantial 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 description is concise (two sentences) and front-loads the purpose. The parenthetical about experiment/demo adds clarity without excessive length, though it could be streamlined.

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

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

The description covers key aspects: what is deleted, what remains, and a critical constraint. However, it omits potential prerequisites (e.g., branch must not be merged) and does not describe the parameter, leaving minor gaps for a simple 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 input schema has one required parameter 'name' with 0% description coverage. The description does not elaborate on the parameter's format, valid values, or how to specify the branch name, failing to add 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?

Description clearly states the tool deletes a branch and specifies it is for cleaning up unnecessary experiment/demo branches. It distinguishes from siblings like merge_branches and rollback_branch by focusing on deletion, and explicitly states main cannot be deleted.

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 indicates when to use (clean up unnecessary branches) and provides a constraint (main cannot be deleted), but does not explicitly compare to alternative tools like rollback_branch or merge_branches, leaving some ambiguity.

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

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

Beyond the destructiveHint annotation, the description reveals that deletion will be rejected if other facts depend on it, adding valuable 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 description is short and front-loaded with the action, but the lack of parameter information makes it less effective despite its brevity.

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

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

The description explains the rejection condition but omits success behavior, return values, and authorization requirements, leaving moderate gaps for a destructive tool.

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

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

With 0% schema description coverage, the description adds no meaning to the 'fid' or 'branch' parameters, failing to compensate for the lack of schema documentation.

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

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

The description clearly states 'Delete fact' and adds context about rejecting if dependencies exist, distinguishing it from sibling tools like add_fact or retag_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?

The description provides a condition (rejection on dependency) but does not explicitly guide when to use this tool versus alternatives, leaving usage implicit.

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

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

Annotations already declare readOnlyHint=true. Description adds ordering and op_id context, but no further behavioral details like output format 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?

Very concise, but at the cost of missing critical information (parameters, output). Good structure but under-specified.

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

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

Simple tool but description omits parameter explanations and output clarity. Insufficient for proper invocation without additional context.

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

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

Schema has 0% coverage; description does not mention the two parameters (limit, branch). Agent has no guidance on values or defaults.

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

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

Description clearly indicates a read operation on branch operation history, newest first, and mentions op_id's use for rollback. Distinguishes from siblings like rollback_branch, though not 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?

No explicit when-to-use or alternatives given. Only a hint about rollback usage, but no differentiation from other read tools like get_state or list_branches.

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

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

Annotations already declare readOnlyHint=true; description adds no extra behavioral traits. No contradiction.

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

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

Two tight sentences, front-loaded with core purpose, zero waste.

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?

Adequate for a simple read-only tool, though return format is unspecified.

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

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

With 0% schema coverage, description minimally explains range parameters but omits branch parameter. Partially compensates.

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?

Explicitly states it returns chapter beats in chapter order, with optional range. Clearly distinguishes from siblings like set_beat.

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?

Describes use case for overview consistency but does not explicitly contrast with alternatives like chapter_brief.

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

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

Annotations already provide readOnlyHint=true. The description adds rich behavioral context: facts have chapter and narrated_in, the two slicing methods (as_of_chapter, as_of_narrated), and the concept of flashbacks. It also explains subject filtering. No contradiction with annotations.

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

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

The description is a single dense paragraph that is front-loaded with the purpose, then explains temporal axes, filtering, and usage. Every sentence adds value; no waste.

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

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

Given no output schema and 4 parameters (none required), the description fully covers return values (facts with chapter and narrated_in), parameter semantics, and usage context. It is complete for the agent to use 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%, so the description compensates by explaining 'subject' (フィルタリング), 'as_of_chapter', and 'as_of_narrated' with detailed temporal semantics. The branch parameter default is implied from schema but not restated. It adds significant meaning beyond the schema.

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

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

The description clearly states the tool returns current valid facts in a branch, with temporal dimensions. It uses a specific verb ('返す', return) and resource ('facts'), and distinguishes from sibling tools like add_fact by being read-only and offering temporal slicing.

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

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

The description gives clear usage context: '章を書く前の状態確認に使う' (used to check state before writing a chapter). It explains the two temporal axes and filtering, but does not explicitly mention when not to use or provide alternatives to other tools.

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

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

Annotations only indicate readOnlyHint: false (mutation). Description adds that the tool does not gate with hard constraints, allowing contradictions, and that audit should be called to reveal them. This is useful behavioral context beyond annotations.

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

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

Description is concise but dense with all critical information (purpose, usage, behavior, param structure). Could be slightly more structured but every sentence adds value. No wasted words.

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

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

Covers purpose, usage, parameter format, behavioral nuance, and post-import action. For a 2-param batch import tool, this is adequate. Lacks mention of error handling or performance implications, but not critical.

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

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

Input schema has 0% coverage (no descriptions). Description defines the structure of 'facts' parameter as '[{subject, attribute, value, chapter, kind?, num?}, ...]', which is essential for the agent to construct valid input. This compensates fully for the missing schema details.

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

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

Description clearly states it's for batch registering facts extracted from existing works, distinguishing it from siblings like add_fact (single), add_facts (batch but without the 'hard constraint' nuance), and propose_canon_facts (canonicalization). The verb '一括登録' (batch register) is specific.

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

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

Explicitly states to use for importing existing manuscripts, not for writing from scratch. Also advises calling audit afterward to surface contradictions. This provides clear when-to-use and when-not-to-use guidance.

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

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

The description thoroughly discloses side effects (integration, canonicity, entity-level checks, returning hard_violations, stopping ALIAS questions). Annotations only provide readOnlyHint=false, but the description adds critical behavioral details beyond this.

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 informative but slightly verbose. It is front-loaded with the main purpose and uses clear structure for the two modes. Some sentences could be streamlined without losing meaning.

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

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

The description covers the tool's return value (hard_violations), side effects, and relationship to answer_question. However, it lacks explanation for the 'branch' parameter and does not mention prerequisites or reversibility, which would be helpful given the complexity.

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

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

The description explains the 'same' parameter in detail and implies the roles of 'a' and 'b' as entity names. However, the 'branch' parameter is not explained, and schema coverage is 0%. The added meaning for three out of four parameters partially compensates for the lack of schema descriptions.

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

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

The description clearly states the tool is for explicitly declaring identity of two names (entities). It distinguishes itself from sibling tools like answer_question by being an active declaration rather than a query. The two modes (same=True/False) and their effects are well explained.

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

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

The description explains when to use each mode (declaring same identity or different identity) and mentions it is used actively without waiting for ALIAS questions. However, it does not explicitly exclude other scenarios or compare with alternatives like answer_question, leaving room for ambiguity.

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

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

The description is consistent with the readOnlyHint annotation, but it does not add any behavioral context beyond what the annotation already provides. No contradictions.

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

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

The description is a single, well-formed sentence that is front-loaded and contains no unnecessary words. Every part is informative.

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

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

Given the tool has no parameters, a read-only annotation, and is a simple list operation, the description is sufficiently complete. It lacks details about the return format but that is minor.

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

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

There are no parameters, and schema coverage is 100%. The description does not need to add parameter details. The baseline for 0 parameters is 4.

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

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

The description clearly states the verb 'list' and the resource 'all branches', and distinguishes from sibling tools like create_branch, delete_branch, merge_branches. It specifies the scope and context of the tool.

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 is minimal and does not provide explicit when-to-use or when-not-to-use guidance. However, for a simple listing tool, the purpose is clear enough that usage context is implied.

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

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

Annotations already declare readOnlyHint=true. The description adds context that constraints are data-driven, version-managed per branch, and have specific fields (cid, template, params, enabled, note). This goes beyond annotations to explain behavior.

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

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

The description is concise, with no wasted words, and front-loads the primary purpose. However, it could be slightly more structured by separating the listing info from the data nature explanation.

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

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

Given the tool's simplicity (one optional parameter, no output schema), the description provides a reasonable overview: what it returns (constraints with fields) and their nature (version-managed). It does not detail pagination or ordering but is adequate for the task.

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%, but the description only implicitly mentions the 'branch' parameter without explaining its purpose, default, or allowed values. The description does not compensate for the lack of parameter documentation.

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

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

The description clearly states the tool enumerates effective constraints for a branch, specifying the resource (constraints) and action (list). It distinguishes from sibling tools like add_constraint or set_constraint, which are write operations.

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

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

The description implies the tool is for listing constraints, but does not explicitly state when to use it over alternatives (e.g., check_constraints) or when not to use it. No contextual guidance is provided.

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

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

Annotations provide readOnlyHint=true, and the description adds context by detailing the types of open questions (ALIAS, MERGE_CONFLICT, SOFT_CONTRADICTION) and their firing conditions, which helps the agent understand what to expect.

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 overly long with implementation-specific bullet points about question types and firing conditions. It lacks conciseness and does not front-load the most critical information for 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?

The description lacks explanation of the output format, does not clarify the role of the 'branch' parameter, and omits behavioral details like pagination or ordering. The tool's context is insufficient for effective use.

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

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

Schema coverage is 0%, and the description does not mention the 'branch' or 'status' parameters at all. The agent has no guidance on how these parameters affect the output.

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

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

The description explicitly states 'list unresolved questions' at the beginning, clearly indicating the tool's verb and resource. It distinguishes from sibling tools like answer_question by directing resolution to that tool.

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

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

The description implies usage by stating that LLM should present questions to the author and pass to answer_question. However, it does not provide explicit guidance on when to use this tool vs alternatives or when to avoid it.

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

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

Description reveals auto-merge behavior and conflict generation (MERGE_CONFLICT). Annotations only set readOnlyHint=false, so description adds valuable behavioral context beyond annotations.

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

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

Three sentences, each providing essential information: purpose, behavior, and conflict handling. No redundant 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?

Covers input and process well, but does not describe output format or return values. With no output schema, this is a minor gap.

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

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

Schema has 0% description coverage and only parameter names. Description explicitly defines 'src' as source branch and 'dst' as destination branch, adding complete meaning.

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

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

Description clearly states the tool merges a source branch into a destination branch using 3-way merge. It distinguishes from sibling tools like create_branch and delete_branch by specifying integration of branches.

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?

Describes when automatic merge occurs (only one side changed) and when conflict arises (both sides change same fact to different values). Advises using answer_question for conflict resolution, providing 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?

Annotations declare readOnlyHint=true, and description confirms it does not commit (コミットしない). It discloses return structure (high_new, low_new, existing, summary) and notes it does not fold into story types (LIFE/RANK).

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 dense and contains rich information but is somewhat verbose and stream-of-consciousness. It front-loads the purpose but could be more organized and concise.

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

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

Given the complexity (4 params, no output schema) and readOnly annotation, the description covers return values, usage flow, and fine-grained behavior. It does not cover error conditions or length limits, but for the intended narrative use it is adequate.

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

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

Schema coverage is 0% and description provides no explanation for the 4 parameters (branch, chapter, chapter_text, pov_character). It only implicitly references chapter_text via 'chapter prose'. No additional meaning is added beyond the schema.

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

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

The description clearly states it generates draft entries from chapter prose, extracts structures, maps to canonical schema, and returns candidates sorted by adoption likelihood. It distinguishes from sibling tools like add_facts (commit) and retag_fact (refine).

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 tells to use after writing chapter text to avoid duplicate work, and guides to check high_new then use add_facts. It also suggests retag_fact for refinement if needed. Missing explicit when-not-to-use but alternatives 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?

Annotations declare readOnlyHint=true, and the description confirms it performs only matching and analysis without modifications. It additionally discloses filtering by known entities and zero anaphora resolution, and explains that output categories indicate potential fabrications or omissions. No contradictions.

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 paragraph that front-loads the core action and output. It efficiently covers key points without redundancy, though the Japanese text is dense and might benefit from clearer structuring for non-native readers.

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 complex with 4 parameters and no output schema. The description explains the return value categories and matching logic, but does not detail all parameters or provide examples. This is adequate but not complete for full agent understanding.

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%; the description only explains the format of 'llm_facts' as an array of subject-predicate objects. Other parameters (chapter, chapter_text, pov_character) are not described, leaving their semantics unclear. With low coverage, the description should provide more parameter details.

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

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

The description clearly identifies the tool's action: reconciling LLM-extracted facts with mechanism-extracted predicate-argument records on subject-predicate axes. It specifies inputs and output categories, distinguishing it from sibling tools like add_fact or delete_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?

The description implies usage for identifying discrepancies between two fact sources but lacks explicit guidance on when to use this tool versus alternatives, and does not mention when not to use it. The note that differences are not definitive provides some 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?

The description adds value beyond the destructiveHint annotation by clarifying that the operation log remains unchanged (history persists) and that fid must come from open_setups. This provides useful behavioral context, though it does not detail all side effects.

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

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

The description is very concise, providing the core purpose in one line with a brief parenthetical. However, the use of Japanese and technical terms like 'fid' and 'open_setups' may reduce clarity for non-Japanese speakers, and it could be structured better.

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 incomplete parameter documentation, the description is insufficient. It assumes domain knowledge about 'setups' and 'open_setups', and does not explain the result of resolving or how to use the branch parameter.

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

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

Schema description coverage is 0%, so the description must explain parameters. It clarifies that fid should be a value from open_setups, but the branch parameter is completely undocumented, leaving its purpose ambiguous.

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

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

The description clearly states the tool marks a setup as resolved, removing it from an unresolved list, and notes that the operation log is unchanged. This provides specific verb and resource, but it does not differentiate from sibling tools like add_setup or delete_branch, and the term 'setup' is not defined in context.

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

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

The description offers no guidance on when to use this tool versus alternatives, such as when to resolve versus delete a setup. No context, exclusions, or alternatives are mentioned.

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

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

It discloses that a hard recheck runs like retcon, leading to status=rejected on conflict, operation log persists, and states limitations on resetting certain fields. Beyond annotations (readOnlyHint=false), it provides essential behavioral details.

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

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

The description is concise (4 lines) yet comprehensive, using clear Japanese and bullet points. Every sentence adds value without redundancy.

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

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

Given 8 parameters, no output schema, and minimal annotations, the description fully covers parameter purposes, side effects, and usage boundaries, making it complete for agent use.

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

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

Schema coverage is 0%, but the description explains each parameter's role (e.g., value/num for update, chapter for move, valid_to for ending lifespan) and clarifies that unspecified parameters remain unchanged.

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

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

The description explicitly states it updates/replaces existing facts without delete+re-add, lists specific use cases (value update, chapter move, attribute reassign), and clearly distinguishes from sibling tools like delete_fact and add_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?

It provides clear when-to-use (updating values, moving chapters, etc.) and when-not-to-use (resetting valid_to/narrated_in to default), with explicit alternative (delete_fact+add_fact).

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

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

The description adds behavioral context beyond the destructiveHint annotation, explaining that the operation log is immutable and rollbacks are reversible. This clarifies that the tool is destructive but safe due to immutability. No contradiction with annotations.

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

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

The description is extremely concise with two sentences, no redundant information, and front-loaded with the core action. Every sentence adds value.

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

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

Given the tool's simplicity, the description covers purpose, behavior, and usage context. It lacks details on error handling or return values, but the absence of an output schema makes this acceptable. It is complete enough for an agent to understand and invoke 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?

Despite 0% schema description coverage, the description implicitly defines both parameters: 'branch' is identified by '[branch]' and 'to_op' as 'past operation ID'. This provides sufficient meaning for a 2-parameter tool, meeting the baseline of 4 for zero documented 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 clearly states the tool's action: rolling back a branch to a past operation ID. It specifies the resource (branch) and action (rollback), distinguishing it from sibling tools like create_branch or delete_branch.

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

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

The description provides explicit context for when to use the tool: as a 'safety net' when contradictions arise from LLM edits. It also notes that rollbacks are reversible due to the immutable log, implying it can be used repeatedly. However, it does not list situations where the tool should not be used.

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

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

Annotations indicate readOnlyHint=false, consistent with write operation. Description adds idempotency (re-registration updates) and states that the beat is included in chapter_brief, providing side-effect information beyond annotations.

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

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

Description is front-loaded with the main action and includes explanatory notes without excessive length. Each sentence adds value, though slightly verbose.

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

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

For a simple tool with 3 parameters and no output schema, the description covers purpose, usage timing, idempotency, and a side effect (inclusion in chapter_brief). Missing return value explanation but acceptable given no output schema.

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

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

Schema coverage is 0%, so description must compensate. It explains that 'beat' is a textual design paragraph but does not describe 'branch' or 'chapter' explicitly. Minimal added meaning beyond schema.

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

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

The description clearly states the tool registers/updates a chapter beat, defining it as a paragraph design for who appears, what happens, etc. It is distinct from siblings like add_fact or set_constraint.

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 advises placing the beat before writing to reduce drift, indicating when to use. It doesn't explicitly exclude after writing, but the context is clear. No alternatives are named, but the tool is specialized.

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

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

The description discloses behavioral traits such as deletion (remove=True), disable/enable (enabled=False/True), and the immutability of operation logs allowing rollback. This adds context beyond the readOnlyHint annotation, which correctly indicates write operations.

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

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

The description is concise (three sentences) and front-loaded with the main purpose. It efficiently covers parameter behavior and priority without wasted words.

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

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

The description covers parameter behavior and conflict resolution, but lacks information about return values or operation confirmation. Given no output schema, the description could be more complete.

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

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

The description explains the meaning of the 'remove' and 'enabled' parameters and their interaction, but does not clarify 'cid' and 'branch' beyond their names. With 0% schema description coverage, the description partially compensates but is incomplete.

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

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

The description clearly states that the tool aggregates lifecycle operations for constraints, including removal, disable, and re-enable. It distinguishes from sibling tools like add_constraint by focusing on modification rather than creation.

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

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

The description provides guidance on when to use remove vs enabled parameters and notes priority when both are specified. However, it does not explicitly compare against sibling tools or state when not to use this tool.

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