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

With no annotations provided, the description carries the full burden and largely meets it: it discloses fail-closed validation and the exact approval-status invariant (stays 'unapproved' unless an authenticated approval was recorded server-side). This tells the agent the operation is gated by server-side state and fails safely. Minor gap: no mention of whether applying answers is reversible or what side effects it has.

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 dense, front-loaded sentences. The first states the operation and its validation mode; the second gives the key approval invariant. Every clause carries meaning, with no filler or repetition of schema 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 tool with no annotations, no output schema, and only 25% parameter coverage, there are notable gaps: no prerequisites are mentioned (e.g., that run_id comes from run_tw_corrections_analysis, which the schema hint implies but the description doesn't state), no guidance on the shape of the nested arrays/objects, and no description of the return value or exact failure behavior. The approval semantics are covered well, but the surrounding workflow 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?

Schema description coverage is only 25% — only run_id has a description. The description partially compensates by mapping 'answers' to human answers, 'procedure_stage_signal' to procedure-stage HITL questions, and 'atomic_items' to correction-item HITL questions, but it gives no structural or format guidance for these nested objects/arrays. This mapping is helpful but thin given three undocumented, nested required 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 uses a specific verb ('Apply') with a clear resource ('human answers to procedure-stage and correction-item HITL questions'), and adds the 'fail-closed validation' behavior. This distinguishes it from siblings like build_hitl_confirmation_packet (constructing the HITL packet) and run_tw_corrections_analysis (running the correction analysis).

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 its use — applying human answers to HITL questions — and scopes it to procedure-stage and correction-item questions, but it never explicitly states when to use this tool versus alternatives or when not to use it. No sibling is named as an alternative, so the agent must infer workflow ordering from context.

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

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

With no annotations, the description carries the full burden. It does not disclose side effects, prerequisites, error conditions, or what 'build' entails (e.g., does it mutate state, require authentication). Minimal 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 sentence is concise but bare. It could be restructured or expanded slightly to include parameter hints or usage context without losing 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?

Given the complexity (nested objects, no output schema, no annotations), the description is insufficient. It does not describe the output format, parameter details, or workflow integration, leaving significant 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?

Schema coverage is 0%, but the description adds no explanation for either parameter (procedure_stage_signal, atomic_items). It does not clarify what these objects represent or how they relate to the output client_questions.

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 builds client_questions for low-confidence procedure stages and manual-review correction items. It uses a specific verb and resource, and the context hints at its place in the workflow, though it does not explicitly distinguish from siblings like apply_hitl_confirmations.

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 (e.g., apply_hitl_confirmations). The description only implies the context but does not provide explicit usage conditions or when not to use it.

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

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

With no annotations, the description must disclose behavioral traits. It mentions 'versioned' and 'return source-bound entries' but lacks details on side effects, mutability, permissions, or idempotency. The description is insufficient for understanding the tool's impact.

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 (one sentence), which is good, but it sacrifices necessary detail. It is front-loaded but too brief to be useful.

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 of the tool (6 params, nested objects, no output schema), the description is severely incomplete. It fails to explain what a 'law snapshot' is, what 'run context' means, or how parameters relate. The tool requires much more context to be used 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 provides no information about any of the 6 parameters (4 required). The agent has no assistance in understanding parameter meanings 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 action ('Build') and the resource ('versioned law snapshot'), and mentions the return of 'source-bound entries'. It is specific enough to distinguish from siblings, but 'run context' is vague and could be more 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?

No guidance is provided on when to use this tool versus alternatives, nor are any prerequisites or exclusions mentioned. The agent is left without context on selection criteria.

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

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

No annotations are provided, and the description does not disclose behavioral traits such as side effects, permissions required, or data mutations. It merely states it builds a packet checklist, leaving agents unaware of potential impacts or 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 a single sentence and is concise, but it is under-specified. It could be trimmed further, but its brevity is not an issue; the lack of content is.

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

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

Given the tool has two parameters, no output schema, and no annotations, the description is severely incomplete. It does not specify what the packet checklist contains, how parameters affect the output, or any constraints for correct invocation.

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

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

With 0% schema description coverage, the description fails to explain the meanings or valid ranges of the two parameters (jurisdiction and procedure_stage). It only mentions procedure_stage in passing, adding no value beyond the schema's property names.

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

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

The description clearly states the action (build), the specific resource (New Taipei submission/completion packet checklist), and the context (for a procedure stage). It distinguishes itself from siblings like build_law_snapshot or build_sheet_manifest by specifying 'New Taipei' and 'submission/completion packet checklist'.

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

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

The description provides no guidance on when to use this tool versus alternatives. It does not mention prerequisites, when not to use it, or relationships to sibling tools like build_hitl_confirmation_packet.

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

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

With no annotations, the description carries full burden. It discloses that the tool does not read raw pixels, but omits other behavioral aspects such as whether it writes data, requires permissions, handles errors, or is destructive. The single behavioral note is insufficient for full 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 concise sentence that quickly communicates the core action and a key constraint (no pixel reading). It is front-loaded and efficient, though slightly more structure (e.g., clarifying output) could improve it without making it 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 the minimalist schema (no output schema, no parameter descriptions) and no annotations, the description should provide more context about inputs, outputs, and behavior. It only addresses input and a single restriction, leaving gaps needed for accurate usage.

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

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

Schema description coverage is 0%, yet the description adds no detail about the 'files' parameter, such as expected structure, allowed file types, or required keys in the objects. The description fails 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 the tool builds sheet_manifest metadata from filenames and explicitly says it does not read raw pixels. The verb 'build' and the specific resource 'sheet_manifest metadata' provide a clear purpose, distinguishing it from tools that process image content. However, the output format is not described, leaving some ambiguity.

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

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

The description implies usage when metadata extraction from filenames is needed without pixel-level processing, but it does not provide explicit when-to-use or when-not-to-use guidance, nor does it mention alternative tools. The context is implied but not clearly 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?

With no annotations provided, the description carries full burden. It states only the purpose, with no disclosure of output format, side effects, or what 'sufficiently supported' implies. The agent cannot infer if the tool returns boolean or confidence scores.

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

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

The description is a single sentence that efficiently communicates the core purpose. However, it lacks structure such as bullet points or separation of parameter info, which would improve readability.

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 3 parameters (including a potentially large 'article_text'), no output schema, and no param descriptions, the description is woefully incomplete. It fails to explain inputs, outputs, or the meaning of 'fail-closed filtering', making it hard for an agent to use 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 does not mention any of the three parameters ('claim', 'context', 'article_text'). The agent receives no guidance on input format, constraints, or the role of the optional 'context' parameter.

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

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

The description clearly specifies the verb 'Check' and the resource 'claim support by article text', with a specific context 'for fail-closed filtering'. This distinguishes it from sibling tools like 'check_fire_compartment_evidence' which operate on different domains.

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

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

The description provides no guidance on when to use this tool vs alternatives. Sibling tools include other 'check_*' functions, but no conditions or exclusions are mentioned, leaving the agent without context for selection.

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

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

With no annotations, the description carries full burden. It says 'find' implying read-only, but does not confirm safety, side effects, or what 'source-bound human-confirmation needs' entails. Insufficient disclosure.

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 (13 words), but the brevity sacrifices clarity. It could be more effective with additional context without becoming overly 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 the tool has 3 parameters (including nested objects), no annotations, and no output schema, the description is completely inadequate. It fails to explain input semantics, return format, or any prerequisites, leaving the agent underinformed.

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

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

Schema description coverage is 0%, and the description does not map to the three parameters (text, atomic_items, sheet_manifest). The description adds no meaning about how these parameters relate to evidence terms or confirmation needs.

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 'Find' and resource 'fire-compartment related evidence terms and source-bound human-confirmation needs', making the purpose clear. However, it does not explicitly differentiate from sibling tools like check_material_evidence, so a slight deduction.

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. There are no conditions, prerequisites, or exclusions provided, leaving the agent without direction for appropriate invocation.

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 must fully disclose behavioral traits. It only states 'fail-closed routing' without explaining what that entails, what happens to inputs, or side effects. No contradiction with annotations as none 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?

The description is a short, fragmented phrase rather than a complete sentence. Conciseness is achieved at the cost of clarity, making it 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?

Given the lack of annotations, output schema, and parameter descriptions, the tool definition is completely inadequate. It provides no useful information for an agent to understand the tool's purpose, behavior, or usage.

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

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

Schema coverage is 0%, and the description fails to explain any of the three parameters (text, files, fire_equipment_change_flag). The phrase 'document/professional confirmation' hints at text/files but provides no concrete semantics.

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 'Fail-closed routing for fire-safety-equipment document/professional confirmation needs' is vague and does not clearly state what the tool does. The verb is ambiguous, and the purpose is not differentiated from sibling tools like check_fire_compartment_evidence.

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

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

No guidance is provided on when to use this tool versus its siblings or other alternatives. The description lacks context for appropriate usage scenarios.

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 must fully disclose behavioral traits. It only states that it does not judge authenticity, but says nothing about side effects, authorization requirements, or whether it is read-only. This omission leaves important behavioral uncertainty.

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

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

The description is a single concise sentence with no redundancy. However, it could be restructured to front-load the key verb and resource more prominently, but overall it is efficiently short.

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 absence of annotations, output schema, and parameter descriptions, the tool definition is severely incomplete. The description does not explain return values, parameter usage, or provide enough context for correct invocation.

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

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

Schema description coverage is 0% for three parameters, yet the description provides no explanation for any of them (text, files, material_records). The description adds no value beyond the schema's structural definition, failing to help the agent understand parameter meaning.

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

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

The description clearly states the action ('check material evidence metadata presence') and includes a clarifying negative ('without judging material authenticity'), which distinguishes it from similar tools like check_claim_support or check_fire_compartment_evidence.

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

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

The description implies when to use it (when only metadata presence is needed) but does not explicitly state when not to use it or mention alternatives among siblings. The negative constraint provides some guidance but lacks directiveness.

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

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

No annotations provided; the description lacks disclosure of side effects, authentication needs, or read-only nature. It only states the result, not behavioral traits.

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 short sentence directly conveys the purpose with no 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?

Missing details on what the differences entail, return format, or definition of P0 sources. Incomplete given no output schema and no explanations.

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 zero parameters and 100% schema coverage, the description adds value by specifying the type of differences and target sources, exceeding baseline of 3.

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 'Return...differences' for a specific resource ('official-source authorization and update-policy') and scope ('P0 sources'), which distinguishes it from siblings like get_source_policy.

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

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

No explicit guidance on when to use this tool vs alternatives like get_source_policy or check_claim_support. The scope 'P0 sources' is mentioned but not explained.

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, and the description does not disclose behavioral traits such as whether it is read-only, destructive, requires authentication, or rate limits. It merely states detection without clarifying side effects or return 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 a single sentence, which is concise, but it omits critical details. It is not front-loaded with key information.

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

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

Given no output schema, no annotations, and minimal parameter info, the description fails to convey usage context, return values, or expected behavior. It is incomplete for an agent to reliably invoke.

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 meaning beyond parameter names. It does not specify expected formats for 'text' or 'files', nor their semantic roles.

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

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

The description uses a specific verb 'Detect' and a resource 'files or text' for 'illegal-construction indicators', but the phrasing 'only imply' is ambiguous, and the purpose of 'manual routing' is not clearly connected. It partially distinguishes from sibling tools that check specific evidence, but could be more precise.

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. No context about prerequisites, typical usage scenario, or exclusions provided.

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

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

With no annotations, the description bears full burden. It discloses that the tool extracts metadata only and prevents raw content from entering agent input, which is a key behavioral trait. However, it lacks details on permissions, error behavior, 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 description is a single sentence that front-loads the core purpose. It is concise, but the lack of parameter information makes it under-specified for practical 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?

Given no output schema, no annotations, and a single undocumented parameter, the description is incomplete. It does not cover what the tool returns, how to format the input, or any prerequisites. The agent cannot reliably call this tool based solely on the description.

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. The description does not explain the 'files' parameter at all—what structure the objects should have, whether these are file IDs or paths, or any constraints. This makes the tool nearly impossible to invoke correctly.

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 extracts metadata-only file contract fields and explicitly avoids allowing raw content into agent input. However, it does not specify what 'file contract fields' are, leaving some ambiguity.

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

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

No explicit guidance on when to use this tool versus alternatives like parse_masked_document. The description implies use for metadata extraction only, but does not provide any context on when not to use it or contrast with sibling tools.

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

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

With no annotations, the description carries full burden but only states the action. It does not disclose whether the tool is read-only, requires authorization, or handles errors (e.g., article not found). Behavioral traits are absent.

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, efficient sentence with no extraneous information. It is appropriately short for such a straightforward tool.

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

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

For a tool with 3 parameters and no output schema, the description omits critical context: what 'P0 law snapshot' means, possible return values, error behavior, and any prerequisites. It is insufficient for an agent to use 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 but only mention two of three parameters. 'law_id' and 'article_no' are named, but no format, constraints, or the optional 'as_of_date' are explained, adding minimal value beyond parameter names.

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

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

The description clearly states the verb ('Get'), resource ('article'), and identifiers ('law_id' and 'article number'), providing a specific and unambiguous purpose. It distinguishes from siblings by naming a unique resource and identifiers.

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

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

No guidance is provided on when to use this tool versus alternatives like 'get_local_rule' or 'search_law'. The description does not mention exclusions or context for selection.

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

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

With no annotations, the description bears full responsibility for behavioral disclosure. It only states the tool 'reports' without indicating side effects, permissions, or response format, leaving significant ambiguity.

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, perfectly concise for the tool's simplicity.

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

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

The description is minimally complete for a zero-parameter tool, but the lack of output schema or details about the return value (e.g., boolean) leaves some ambiguity.

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%, so the description does not need to add parameter details. A baseline score of 4 is appropriate.

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

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

The description clearly states the tool reports whether a fixture baseline satisfies G2, using a specific verb and resource. It distinguishes from siblings by its specific function, though 'G2' is not 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?

No guidance is provided on when to use this tool versus siblings. Given zero parameters, usage is implicit, but no context or prerequisites 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?

With no annotations, the description carries the full burden, and it does disclose a meaningful behavioral trait: rules in inactive, pending, ambiguous, malformed, missing-lifecycle, or historically indeterminate states fail closed. It stops short of explaining what 'fail closed' concretely returns, such as an error or empty result, and mentions no auth or side-effect 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?

A single dense sentence front-loads the operation and then precisely enumerates the fail-closed conditions. Every clause adds information, with no filler or 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?

For a tool with 3 parameters, no annotations, no output schema, and a long sibling list, the description omits parameter semantics, usage routing, and the concrete meaning of 'fail closed'. An agent would still need to infer or experiment 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%, so the description must compensate, but it never explains jurisdiction, rule_name, or as_of_date. The phrase 'lifecycle-aware' and 'historically indeterminate' weakly hints that as_of_date affects the lifecycle determination, but this is not stated explicitly or mapped to any parameter.

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

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

The description clearly identifies a specific verb ('get') and resource ('structured local-law metadata'), and adds 'lifecycle-aware' to signal what kind of metadata is returned. This meaningfully distinguishes it from general search or article/retrieval siblings, though it does not explicitly contrast with get_source_policy or search_law.

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 wording implies use when the agent needs structured local-law metadata with lifecycle awareness and fail-closed behavior. However, it provides no explicit guidance on when to prefer this over sibling tools like search_law, get_article, or get_source_policy.

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

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

No annotations are present, so the description carries the burden. It only lists return values but does not disclose read-only status, side effects, permissions, or response format. Behavioral traits are minimal.

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

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

The description is a single, clear sentence with no unnecessary words. It is efficient but could be slightly more informative without losing 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?

Given the simple nature of the tool (one parameter, no output schema), the description covers the basic return values but lacks behavioral context and parameter details. It is minimally adequate but not fully complete.

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

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

With 0% schema description coverage and only one required parameter 'source_url', the description adds no additional meaning beyond the schema. It does not specify format, examples, or constraints, leaving the agent with incomplete information.

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 'Return' and the specific resource 'authority rank, license status, update policy, and crawl policy for a source URL', making the purpose unambiguous. It also helps distinguish from sibling tools like 'compare_source_policies' which performs a different 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?

There is no guidance on when to use this tool versus alternatives. No context about typical use cases, prerequisites, or exclusions is provided.

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

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

No annotations are provided, so the description bears full responsibility. It mentions 'enabled' and 'disabled stubs' but does not explain what a stub is, the implications of enabling/disabling, or whether the operation is read-only. This leaves significant gaps in behavioral understanding.

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

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

The description is a single sentence with no wasted words. It is efficient, though it could be slightly expanded for clarity without losing 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?

Given the tool has 1 parameter, no annotations, and no output schema, the description is too minimal. It does not describe the return format, pagination, error cases, or the context of jurisdiction registry entries.

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 add meaning. The description only paraphrases the boolean parameter (include_disabled) without naming it or specifying its type. It adds no additional context about the parameter's semantics, format, or default value.

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

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

The description uses a specific verb ('List') and resource ('jurisdiction registry entries'), and it clearly distinguishes between two modes: enabled only or including disabled stubs. This is precise and differentiates the tool from 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?

No guidance is provided on when to use this tool versus alternatives. Among sibling tools, there are many other listing and search tools, but the description does not indicate context or exclusion criteria.

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

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

The term 'list enabled' implies a non-destructive read operation, but no further behavioral details (e.g., pagination, limits, authentication needs) are provided. With no annotations, some burden is on description, but it's adequate.

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

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

Single sentence with no waste. Essential information front-loaded.

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

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

Given three required parameters (one nested object) and no output schema, description lacks details on return format, parameter structure, and edge cases. Incomplete for effective use.

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

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

Schema coverage is 0%, so description should compensate. It names the parameters but does not explain formats, constraints, or the structure of the object parameter (jurisdiction). Minimal value added.

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 lists enabled law packs for Taiwan/New Taipei with specific verb and resource. It is distinct from siblings which are about building, running, or checking other items.

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?

Description specifies when to use (for listing law packs) and includes required context (jurisdiction, case type, procedure stage). No explicit when-not or alternatives, but clarity is high.

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 omits any behavioral traits such as whether the operation is read-only, idempotent, or requires authentication. The description only mentions normalization without side effects.

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

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

The description is a single concise sentence with no wasted words. It is appropriately front-loaded. However, it could be improved by including a brief list or additional context without adding significant length.

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

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

Given the tool has 3 parameters (one nested object) and no output schema, the description is grossly insufficient. It does not explain what 'atomic correction items' or 'source spans' are, nor how the input maps to output. The agent cannot fully understand the tool's purpose or usage.

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

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

The input schema has 3 parameters with 0% description coverage. The tool description does not explain any parameter meaning or how they relate to 'parsed document sections'. The 'document_parsed' object is left undefined, making selection and invocation confusing.

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 normalizes parsed document sections into atomic correction items with source spans, specifying the input and output. However, it does not differentiate from sibling tools like build_hitl_confirmation_packet or build_law_snapshot, which may also involve corrections.

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

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

No guidance on when to use this tool vs alternatives, no prerequisites or exclusions mentioned. The agent gets no context on appropriate usage scenarios.

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

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

No annotations provided, and the description gives minimal behavioral info beyond 'parse'. It doesn't disclose whether the operation is read-only, if it modifies data, or any side effects.

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

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

The description is a single sentence with no wasted words, but it is too terse to fully inform the agent. It sacrifices necessary details for brevity.

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

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

Given the tool has 3 parameters, no output schema, and no annotations, the description is far too sparse. It does not explain output format, how parameters interact, or the meaning of 'procedure-stage signal'. The agent would struggle 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 0% and the description only hints at the 'text' parameter. The 'files' and 'jurisdiction' parameters are completely unexplained, leaving the agent uncertain about their purpose.

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

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

The description clearly states the action (parse) and specific resource (masked Taiwan official-document text) and outputs (document_parsed fields, procedure-stage signal). While it doesn't explicitly differentiate from siblings, the verb and resource combination make it distinct.

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 (e.g., other parsing or extraction tools). No prerequisites or exclusions 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?

Without annotations, the description carries the full burden. It mentions not using live search but fails to disclose what 'corpus misses' means, what the plan contains, or any side effects (e.g., data retrieval, state changes). The lack of behavioral detail 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 a single sentence of 12 words, making it concise but too terse. Important details (parameters, behavior) are missing, so it sacrifices completeness for brevity.

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

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

Given the lack of annotations, output schema, and 3 parameters, the description is inadequate. It does not explain parameter semantics, the structure of the return plan, or the 'fallback' trigger, leaving the agent underinformed.

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 3 parameters with 0% description coverage. The tool description adds no parameter-level information, so the agent must guess the purpose of 'reason' and 'jurisdiction' and how they affect the plan.

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 a fallback plan for corpus misses without using live search. The verb 'return' and resource 'official-source fallback plan' are specific, and the scope (corpus misses, no live search) distinguishes it from sibling search tools like 'search_law'.

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 corpus misses when live search is inappropriate, but it doesn't explicitly state when not to use it or mention alternative tools. Among siblings, search_law and get_article are likely alternatives, but no guidance is 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 provided, and the description does not disclose any behavioral traits beyond returning requirements. No mention of side effects, permissions, rate limits, or return format.

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

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

Single sentence, 10 words, front-loaded with purpose. Could add more specificity without sacrificing 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?

Given the tool has 2 required string parameters with no schema descriptions, no output schema, and no annotations, the description is severely incomplete. It fails to explain parameter formats, valid values, or return structure.

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 no enums. The description does not explain the meaning or valid values for 'stage' or 'jurisdiction' parameters, leaving the agent with no guidance.

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 stage-specific New Taipei interior renovation procedure requirements, with a specific verb and resource. It distinguishes from sibling 'resolve_procedure_stage_confidence' which handles confidence, not requirements.

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

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

No guidance on when to use this tool vs alternatives. No context for prerequisites or required 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?

No annotations are provided, so the description carries the full burden. It discloses a key behavioral trait: low confidence results in routing to HITL. However, it does not mention other important aspects such as whether the tool is read-only, required permissions, potential side effects, or error conditions.

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

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

The description is a single sentence with no wasted words. It effectively conveys the purpose, inputs, and outcome, making it easy to parse quickly.

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

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

For a tool with 3 parameters, no output schema, and no annotations, the description omits crucial information. It does not explain the output format (e.g., score value or boolean), the meaning of the 'jurisdiction' parameter, or any prerequisites. The mention of HITL routing adds context, but overall completeness is low.

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 add meaning. It links 'text' and 'files' to the input sources ('document text and file metadata'), providing partial semantics. However, the 'jurisdiction' parameter is not mentioned, leaving its purpose 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 clearly states the verb 'Score procedure_stage confidence' and identifies the input sources (document text and file metadata). It also mentions a key outcome (low confidence routes to HITL). However, it does not explicitly distinguish from sibling tools like 'resolve_procedure_requirements', so a score of 4 is appropriate.

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

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

The description implies when to use this tool (when confidence scoring from text and file metadata is needed), but it provides no explicit guidance on when not to use it or which alternatives might be more suitable. Sibling tools like 'apply_hitl_confirmations' suggest related functionality but aren't referenced.

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

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

With no annotations, the description carries the full burden of disclosing behavioral traits (side effects, permissions, etc.). It only states it 'resolves... routing', which could be a read or write operation. No mention of idempotency, data mutations, or required permissions. The description does not contradict any missing annotations, but it adds minimal transparency.

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

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

The description is extremely short (one sentence), but it does not earn its place because it is too vague. It is not front-loaded with important information; it uses generic language ('resolve', 'routing') that does not convey enough detail. True conciseness would capture the tool's essence without sacrificing clarity.

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

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

Given the tool's complexity (9 parameters, no output schema, no annotations), the description is grossly incomplete. It does not explain what output is returned, what the parameters control, or any business logic. An agent cannot reliably invoke this tool without additional documentation or examples.

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 9 parameters with 0% description coverage (no descriptions in the schema), and the tool description does not explain any of them. The description mentions 'jurisdiction' and 'case_type' only implicitly via the schema requirements. It fails to add meaning beyond the schema, such as what each parameter means or how they influence routing. For a tool with many parameters, this is severely lacking.

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 specifies a verb ('Resolve'), a resource ('Taiwan/New Taipei interior renovation scenario routing'), and a target ('source packs, artifacts, and gates'). However, 'resolve' is vague and does not clarify whether it is a lookup, transformation, or routing decision. It distinguishes from some siblings (e.g., 'check_*' tools) but not from other 'resolve_*' tools. Overall, it conveys a general purpose but lacks precision.

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

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

No guidance is provided on when to use this tool versus alternatives. The description does not mention prerequisites, limitations, or conditions. Without explicit usage context, an agent cannot determine when to invoke this tool over similar siblings like 'resolve_procedure_requirements' or 'check_material_evidence'.

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 must disclose behavioral traits. It only states 'deterministic' but omits side effects, permissions, idempotency, or error handling. No mention of whether it modifies state or requires specific access.

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

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

The description is a single sentence, which is concise, but it lacks critical details. Brevity without completeness is not effective. The structure is adequate but could be improved by front-loading key information.

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

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

Given the complexity of running multiple audit gates with nested object parameters and no output schema, the description is incomplete. It fails to explain return values, required context, or how the gates are combined.

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 adds no information about the parameters 'correction_items' or 'data_governance_state'. The list of gate types does not clarify the structure or expected inputs. Essential semantics are missing.

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 verb 'run' combined with 'deterministic audit gates' and the explicit list of gate types (schema/citation/source/claim/redline/governance) provides a clear purpose. However, it does not differentiate from sibling tools that perform individual checks or similar multi-gate runs.

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 sibling tools like check_claim_support or run_tw_corrections_analysis. The description does not specify prerequisites, context, or alternative tools.

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

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

No annotations are provided, so the description must fully disclose behavior. It states 'Verify' suggesting a read-only check, but it does not mention side effects, return format, or what happens on failure. The lack of parameters implies reliance on a pre-existing context, but this is not clarified.

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

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

The description is a single sentence with no unnecessary words. It is concise and front-loaded with the core action and objects.

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, no annotations, and a complex sibling landscape, the description is insufficient. It does not explain what 'acceptance' entails, how results are presented, or how to interpret failures. The tool's behavior in the broader workflow is unclear.

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

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

There are no parameters, so the input schema fully covers the input (trivially). The description adds no value beyond the schema, but the baseline is 4 due to high schema coverage.

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

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

The description clearly specifies the verb 'Verify' and lists specific resources (split source packs, registries, fixtures, normalized source_unit contracts), making the tool's purpose clear. However, it does not differentiate this tool from sibling tools like 'run_packaging_acceptance' or 'run_jurisdiction_registry_acceptance', which are also acceptance verifications.

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

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

The description provides no guidance on when to use this tool versus other acceptance tools. No use cases, prerequisites, or alternatives are mentioned, leaving the agent to infer usage 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 present, so the description must fully disclose behavior. It mentions running through multiple steps but does not specify side effects, whether it is read-only or destructive, error handling, or what happens to data.

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

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

The description is a single sentence, concise and front-loaded with the key action. It efficiently conveys the pipeline steps 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?

Despite having no parameters, the tool runs a complex pipeline and lacks context on implicit inputs, acceptance criteria, or output format. The description is too brief for an agent to fully understand the tool's role.

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 zero parameters in the input schema, so no parameter documentation is needed. 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 states a specific verb ('run') and resource ('synthetic G2 fixture baseline'), and outlines the pipeline stages. It distinguishes from sibling tools like 'run_audit_gates' and 'run_phase_acceptance' by being a combined run. However, the term 'synthetic G2 fixture baseline' and 'acceptance' could be more clearly defined.

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

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

No guidance is provided on when to use this tool versus its siblings, prerequisites, or order of operations. The agent has no information about when this pipeline is appropriate.

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

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

No annotations are present, so the description must fully convey behavior. It states the tool 'verify' entries but does not disclose whether it is read-only, what side effects occur, or what happens on failure. The behavioral description is minimal.

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

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

The description is a single sentence of 11 words, containing no filler or redundancy. It is extremely concise and front-loaded with the key action.

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

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

Given the tool has no parameters, no output schema, and no annotations, the description is adequate for a simple verification tool. However, it lacks explanation of domain-specific terms ('fail-closed', 'law-pack coverage') and does not specify what the output or result indicates, leaving context 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?

The tool has zero parameters, so the schema provides no meaning. The description adds the entire semantic context, explaining what the tool does. Following the rule for 0 parameters, baseline is 4.

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

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

The description clearly states the action (verify) and the resource (jurisdiction registry entries), specifying conditions (enabled or fail-closed with law-pack coverage). However, the jargon 'fail-closed' and 'law-pack coverage' may be opaque to an agent without domain knowledge, slightly 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 guidance is provided on when to use this tool versus sibling acceptance tools (e.g., run_packaging_acceptance, run_phase_acceptance). The description does not differentiate its context or indicate prerequisites or limitations.

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 full behavioral burden. It describes a verification action but provides no details on side effects, required permissions, return format, or pass/fail criteria. The agent cannot anticipate how the tool affects 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?

A single, front-loaded sentence with no wasted words. Every part serves to define 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?

Given no output schema, no annotations, and a complex domain (MCP server packaging strategy), the description is too terse. It lacks context on what 'preserve' means, expected outcomes, or how results are reported. Minimal viability but clear 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?

The input schema has zero parameters with 100% coverage. Per guidelines, 0 parameters baseline is 4. The description does not add parameter docs, but none are needed.

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

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

The description starts with a clear verb 'Verify' and specifies exactly what is verified: 'Codex and Claude Code wrappers preserve standalone MCP server packaging strategy.' This distinguishes it from sibling acceptance tests that focus on other areas (e.g., data layout, source policies).

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 other acceptance tests. The description does not mention prerequisites, scenarios, or exclusions, leaving the agent to infer usage 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 for behavioral disclosure. It says the tool 'Run[s]' acceptance and includes a validation scope, but it does not disclose whether this is read-only, whether it produces a report, what side effects may occur, or what the outcome signifies.

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

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

A single sentence that front-loads the core action and scope, with no filler or redundancy. The appended 'including local-rule lifecycle validation' earns its place by clarifying one of the components of the acceptance run.

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 no-parameter tool this is minimally callable, but without annotations or an output schema the description still leaves important gaps: what results the agent should expect, whether state changes, and what 'acceptance' and 'Phase gates' concretely entail. The description is too thin to make the agent confident about downstream behavior.

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

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

The input schema has zero parameters and 100% schema coverage, so there are no parameter semantics for the description to explain. The mention of 'local-rule lifecycle validation' adds scope context, which is the only additional semantic value needed here.

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 action ('Run aggregate acceptance') and a specific scope ('all roadmap Phase gates'), and adds a meaningful detail ('including local-rule lifecycle validation'). It is not a tautology and the 'aggregate' wording helps distinguish it from the many sibling acceptance tools that target narrower areas.

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 phrase 'aggregate acceptance for all roadmap Phase gates' implies this is the umbrella tool versus the more specific sibling acceptance tools, but the description never explicitly says when to prefer this tool or names an alternative for single-phase work. Usage is inferable but not 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 provided, so the description should disclose behavioral traits. It only states it 'verifies' but does not mention side effects, error handling, or whether it is read-only.

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

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

Single, front-loaded sentence with no extraneous words. Every part 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?

Lacks details on return values, failure behavior, or integration context. Without annotations or output schema, the description leaves significant gaps for an agent to decide whether to invoke the 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 no parameters, so the description does not need to add parameter meaning. Baseline is 4 for zero-parameter tools.

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 specifies the verb 'Verify' and the resource 'Taiwan scenario matrix fixtures', listing explicit aspects verified (corpus packs, tool boundaries, artifacts, gates, HITL policies). It is clear but does not differentiate from sibling acceptance tools.

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

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

No guidance on when or when not to use this tool, nor any alternatives mentioned. The description only states what it does without context for selection.

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

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

No annotations are provided, so the description must carry the full burden. It only says 'Verify', implying read-only, but does not disclose side effects, auth needs, or what happens on failure. Minimal behavioral disclosure.

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

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

Single sentence, no fluff. However, it could be slightly more descriptive without harming conciseness. Still, it's 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?

Does not explain what 'normalized source_units' are or the context of acceptance testing. No output schema provided. Leaves many open questions for a complex domain.

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

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

No parameters exist, and schema coverage is 100%. The description adds no parameter info, but with zero parameters, it's adequate. Baseline 4 for zero params.

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 'Verify' and the resource 'deterministic source adapters produce normalized source_units'. It distinguishes itself from sibling 'run_*_acceptance' tools by specifying the focus on source adapters.

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. With many similar acceptance tools, the agent needs more context to select 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?

With no annotations provided, the description carries the full transparency burden. It does disclose the verification logic and implies a read-only validation, which is helpful. However, it does not describe the return format, failure behavior, required state of the source packs, or whether the operation has any side effects.

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

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

The description is a single sentence, front-loaded with the verb and resource, and uses a colon to introduce a tight list of the three checks. Every word contributes meaning; there is no repetition of the tool name or filler 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 zero-parameter tool, the invocation shape is simple and the acceptance criteria are clearly defined. However, with no output schema and no annotations, the description omits what the caller should expect as a result (pass/fail vs. detailed report) and does not explain how this tool relates to the large set of sibling acceptance tools.

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

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

The input schema is empty and there are zero parameters, so schema coverage is trivially 100%. There are no parameter semantics for the description to clarify, so this dimension sits at the baseline 4 for zero-parameter tools.

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 job with a specific verb ('Verify') and resource ('the law corpus against the source packs'), then lists three concrete acceptance criteria: pack-referenced articles exist, every article has a source policy, and pending articles have no unverified text. This makes the tool's scope immediately understandable and distinguishes it from sibling acceptance tools like run_source_policy_acceptance.

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 sibling acceptance tools, such as run_source_policy_acceptance, run_source_adapter_acceptance, or run_packaging_acceptance. The description states what the tool checks but not when it should be chosen or what prerequisites or alternatives exist.

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

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

With no annotations, the description carries the full burden of behavioral disclosure. It only states the verification purpose but does not indicate side effects (e.g., read-only vs. mutation), required permissions, output format, or any constraints. This is insufficient for a tool with no annotation support.

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, clear sentence with no waste. It is front-loaded with the key action and resource.

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

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

Despite zero parameters and no output schema, the description lacks completeness for a verification tool. It does not explain what 'complete' means, what constitutes a pass/fail, or what the tool returns. Compared to siblings like run_audit_gates (likely more detailed), this is inadequate.

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 zero parameters, and schema coverage is trivially 100%. The description does not need to add parameter details. The baseline of 4 applies because no parameter explanation is required.

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

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

The description clearly states the tool's purpose: verifying P0 article sources have complete official-source policy evidence and comparison coverage. It uses a specific verb ('verify') and resource ('sources'), distinguishing it from sibling tools that check other aspects or perform different acceptance tests.

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

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

The description provides no guidance on when to use this tool versus its many sibling tools, no prerequisites, and no exclusions. It fails to help an agent decide between tools like check_claim_support or run_audit_gates.

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 behavior. It only states the action and inputs; it does not say whether the tool is read-only, what side effects it may have, what it returns, what permissions are needed, or how it handles failures. The word 'analysis' hints at a read-style operation, but that is not 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?

The description is a single sentence with no fluff or repetition. It front-loads the action and stage, then clarifies the input sources, making it easy to scan while remaining compact.

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

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

For a tool with six parameters, a nested object, no output schema, and no annotations, this one-sentence description is far from complete. It does not explain what the analysis returns, how the parameters combine, what metadata-only files should contain, or how this stage fits into the broader acceptance pipeline.

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

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

The input schema has 0% description coverage, and the description only adds meaning for text ('masked') and files ('metadata-only'). The remaining parameters—as_of_date, jurisdiction, procedure_stage, and data_governance_state—receive no additional context, and there are no enums or format details provided. This is only partial compensation for the schema's lack of 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 names a specific action ('Run'), a resource ('stage 1 Taiwan corrections analysis'), and the input source ('masked text and metadata-only files'), so an agent can identify this as the first-stage analysis tool. The 'stage 1' qualifier helps distinguish it from sibling tools like run_tw_corrections_response, though 'corrections analysis' itself remains somewhat domain-specific and underspecified.

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 mention of 'stage 1' and 'masked text and metadata-only files' implies the tool is meant for the initial analysis phase using those specific inputs. However, there is no explicit guidance on when to use this tool versus alternatives, no exclusions, and no named sibling tools such as run_tw_corrections_response or run_two_stage_flow_acceptance.

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 does this well by revealing that artifacts are verified against the server-issued run digest, caller-asserted confirmation fields are ignored, and unapproved answers fail closed. This is security-relevant behavioral context that an agent needs before invoking the 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?

Two dense sentences with no filler. The purpose is front-loaded, and the behavioral caveats are packed into a compact second sentence. Every clause earns its place.

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

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

For a complex two-stage acceptance tool with no output schema, the description covers the core invocation context: inputs, stage relationship, verification behavior, and failure semantics. It does not describe the return value or side effects, but the verifiability and fail-closed details give the agent enough 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 only 33%, so the description must compensate. It explains that analysis_artifacts are verified against the run digest and that answers are human-provided with caller-asserted confirmation fields ignored. However, it does not specify the structure of analysis_artifacts or answers, and run_id is only described in the schema, leaving some semantic gaps.

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 opens with a specific verb ('Run'), a specific stage ('stage 2 Taiwan corrections response'), and clear inputs ('analysis artifacts and human answers'). It is immediately distinguishable from the sibling run_tw_corrections_analysis, which is the stage-1 counterpart, and from other acceptance tools.

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

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

The phrase 'stage 2' and the reference to artifacts from analysis make clear this tool runs after run_tw_corrections_analysis. It does not explicitly name alternatives or state when not to use it, but the two-stage framing provides adequate contextual guidance.

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

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

With no annotations, the description must disclose behavioral traits. It only says 'Verify' but does not explain what verification entails (e.g., side effects, permissions, return value). The description lacks critical 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 a single, concise sentence. However, it uses jargon that may confuse an agent, slightly reducing clarity.

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

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

Given the complexity implied by the tool name and the presence of many sibling acceptance tools, the description is too minimal. It does not explain what 'deterministic' means, what the acceptance criteria are, or what the tool returns, leaving the agent underinformed.

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

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

The input schema has no parameters, and the description adds no parameter information, which is acceptable because there are none. Schema coverage is 100%, so no additional meaning is needed 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 states 'Verify deterministic two-stage Taiwan contractor flow artifacts and red-line policy,' which identifies the tool's purpose as verification of specific artifacts and policies. However, the terms are vague and not clearly defined, making it difficult to distinguish from sibling acceptance tools.

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

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

The description provides no guidance on when to use this tool versus alternatives, such as other acceptance tools. No context about prerequisites or exclusions is given.

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

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

With no annotations, the description must disclose behavioral traits. It mentions deterministic results and included fields, but does not indicate if the tool is read-only, requires permissions, or has side effects. The lack of any behavioral hints beyond basic purpose is a 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, efficient sentence that states the action and output. It is front-loaded and to the point, though it could be expanded with parameter details without losing 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?

Given the tool has 4 parameters (1 required) and no output schema or annotations, the description is inadequate. It lacks essential context on parameter usage and constraints, leaving the agent underinformed for proper invocation.

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

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

Schema description coverage is 0%, and the description only lists output fields, not parameter meanings. The four parameters (query, authority, hierarchy, as_of_date) are not explained at all, adding no semantic value for the agent.

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

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

The description clearly states the function as searching a specific law snapshot and lists the output fields. It distinguishes this tool from other retrieval tools like get_article by specifying the search nature and data source, though 'P0 law snapshot' may be jargony.

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 (e.g., get_article, get_source_policy). There is no mention of when to apply filters like authority or hierarchy, or when not to use the tool.

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

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

With no annotations provided, the description adds some behavioral context by stating the tool is deterministic and not legal assurance. However, it does not disclose what happens when a citation does not exist or any other behavioral traits.

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

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

Two sentences with no wasted words. The purpose is front-loaded and the additional clarification on determinism is 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 tool has three parameters with no schema descriptions, no output schema, and no annotations, the description is insufficient. It does not explain return values, error conditions, or parameter constraints, leaving significant gaps for correct invocation.

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

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

Schema coverage is 0%, meaning the input schema provides no descriptions for the three parameters (law_name, article_no, effective_date). The tool description adds no explanation of these parameters, leaving the agent without guidance on how to fill 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 clearly states the verb 'verify' and the resource 'citation existence in P0 snapshot', and distinguishes it from legal assurance. It is specific and differentiates from sibling tools like check_claim_support.

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

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

No explicit guidance on when to use this tool versus alternatives like search_law or get_article. The description only clarifies it's deterministic, but does not provide when/when-not criteria.

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