bimhouse

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

With no annotations provided, the description carries full burden. It discloses that 'DB + cache applied immediately' and that it operates on 'any houses' via admin token. However, it does not detail whether the operation is destructive (overwrites existing data) or merges, nor does it describe error handling, rate limits, or partial update behavior. Adequate but not comprehensive.

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

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

The description is concise with no fluff. It front-loads key information (admin only, bulk, immediate effect) and then details the entries format and use case. The bilingual presentation (English and Japanese) is necessary. Every sentence earns its place.

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

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

Given no output schema, the description should ideally mention what the tool returns (e.g., success count, error details). It omits return value info but covers purpose, usage, and effects well. For a mutation tool, the immediate effect disclosure is good. Minor gap for completeness.

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

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

Schema description coverage is 100%, so baseline is 3. The description adds value by listing the optional fields in entries (zoning, road_width_m, etc.) and clarifying that slug is required per entry. It also explains the relationship between slug and entries parameters (single vs bulk). This context enhances understanding beyond the schema.

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

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

The description clearly states the tool's purpose: 'Bulk-set site conditions for any houses (admin only, admin_token; no edit_token)'. It specifies the resource (site conditions) and action (bulk-set), and distinguishes from sibling tools by emphasizing admin-only and bulk operation. The use case for backfilling data from reinfolib adds context.

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

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

The description explicitly notes 'admin only, admin_token; no edit_token', indicating authentication requirements and that edit_token is not needed. It gives a concrete use case: 'For operators to backfill zoning/road-width across all properties'. However, it does not explicitly name alternative tools like set_site_context for single house updates, though the context is implied by the sibling list.

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

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

No annotations are provided, so the description carries the full burden. It mentions authentication requirements and domain focus, but does not disclose rate limits, response format, or error 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 somewhat verbose and mixes languages (English and Japanese), which may be acceptable for a multi-language tool but could be more concise. The key points are present but front-loaded with less critical details.

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

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

Given the tool is a chat interface with no output schema, the description covers essential aspects: what topics it handles, authentication, pricing, and parameter usage. It is largely complete for its complexity.

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

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

The description adds meaning beyond the schema by specifying that 'message' is required and 'history' is optional with a specific structure (array of {role, content}). This is helpful for invocation.

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

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

The description clearly states the tool is an AI chat about specific domains (architecture, BIM, code, MU) and is distinct from the sibling tools which are more action-oriented (e.g., create_house, delete_zoning_rule).

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

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

The description provides clear usage context: requires API key, has free initial credits, and accepts an optional history parameter. However, it does not explicitly state when not to use it or suggest alternatives.

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

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

With no annotations, the description carries the full burden. It discloses that the tool is rate-limited, creates private houses by default, auto-generates elements if not provided, and responds with specific URLs and verdicts. It also covers climate-aware upgrades and auto-placement of features based on room names. Minor omission: does not mention error handling or idempotency.

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 thorough and front-loads the core purpose. It covers many details in a structured way, though it is somewhat lengthy due to bilingual content. Most sentences add value, but it could be slightly more concise without losing 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 18 parameters and no output schema, the description covers input behavior and return values (slug, edit_token, URLs, verdicts) well. It explains auto-generation logic and project type impacts. It could mention the structure of the returned verdicts, but overall it is complete for a complex tool.

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

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

Schema coverage is 100%, providing a baseline of 3. The description adds significant value beyond schema, e.g., for 'address' it explains geocoding and auto-naming; for 'rooms' it lists auto-features; for 'project_type' it details cost implications. This enriches parameter understanding.

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

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

The description clearly states the tool creates a new house from address or full elements, with specific verb 'Build' and resource 'house'. It distinguishes from sibling tools like 'update_house' and 'get_house_bim' by focusing on creation and listing the return items (slug, edit_token, URLs, verdicts).

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

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

The description explains that address alone can be used for automatic geocoding and naming, and that elements can be provided to override auto-generation. It also mentions project types (new, renovation, change_of_use) and their effects. However, it does not explicitly state when not to use this tool or list alternatives, though the context of creation vs. updating is implied.

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

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

With no annotations provided, the description carries the full burden. It discloses authentication needs (Bearer API key), insert-only behavior (no overwrite), and immediate propagation to /catalog and search_catalog. However, it does not mention error handling (e.g., duplicate SKU) or rate limits, which would enhance 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 concise given the tool's complexity, mixing English and Japanese efficiently. It front-loads the core purpose and key constraints. The bilingual format is space-efficient but could be more structured (e.g., bullet points) for improved scannability.

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

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

For a tool with 18 parameters and no output schema, the description provides essential context (auth, insert-only behavior, immediate reflection) but lacks information on the response format, error cases (e.g., duplicate SKU), and whether the operation is idempotent. Given the complexity, more detail would be justified.

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 100% with detailed parameter descriptions (e.g., SKU format, category examples). The tool description adds no extra parameter information beyond what the schema provides, so it meets the baseline but does not exceed it.

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

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

The description clearly states 'Register a new catalog product SKU' and emphasizes 'insert-only, no overwrite', which distinguishes it from sibling tools like update_product and retire_product. The specific product categories (sash, windows, insulation, etc.) further clarify scope.

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

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

The tool description specifies prerequisites (Bearer API key) and notes that it is insert-only, implying that updates should use alternative tools (update_product exists as sibling). It also mentions immediate reflection in catalog and search, but does not explicitly name the alternative tool, which would improve guidance.

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

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

No annotations are provided, so the description must convey behavioral traits. It mentions the effect (reverts to defaults) and access restriction (admin only), but does not disclose whether the operation is reversible, what the response looks like, or any side effects. Adequate but not comprehensive.

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 covers purpose, effect, and access control. Bilingual format adds utility without bloat. Every element is necessary and efficiently presented.

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

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

The tool has no output schema, so the description should explain return value or success indicators. It does not. For a mutation (delete) tool, the agent needs to know what to expect after invocation. The description is incomplete in this regard.

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

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

Schema description coverage is 100%, so the schema already documents all parameters with Japanese descriptions. The English description does not add further semantic detail beyond what the schema provides, so baseline score of 3 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 explicitly states the verb 'remove' and the resource 'zoning rule override', and specifies that it reverts to engine defaults. It also notes 'admin only', clearly distinguishing this tool from siblings like upsert_zoning_rule.

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

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

The description indicates admin-only use and reverting to defaults, but does not explicitly contrast with the sibling tool upsert_zoning_rule. It implies that this tool is for removing overrides while upsert is for creating or updating, but no direct guidance is provided.

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

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

With no annotations provided, the description carries the full burden. It describes the return content and mentions auto-generation (implying computation), but does not explicitly state if it is read-only, required permissions, or potential side effects. It adds some context beyond schema but lacks depth.

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

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

Description is short (two languages) and front-loaded with English. Each sentence adds value: it specifies what the plan contains and that it is auto-generated. Could be slightly more concise by dropping the repeated Japanese, but still efficient.

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

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

Given no output schema, the description provides a good overview of the return value (schedule, cost, lead, constraints, checklist). It mentions auto-generation, which is useful context. It does not explain the input slug in detail, but overall it is complete for a retrieval tool.

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

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

Schema coverage is 100% (single parameter 'slug' is described). The description adds no additional meaning beyond the schema's '物件 slug'. Baseline score of 3 is appropriate as schema suffices.

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 construction plan for a house with specific components (Gantt schedule, per-trade order packages). The verb 'get' combined with the resource 'build plan' is unambiguous, and the content distinguishes it from sibling tools like 'get_house_bim' which returns BIM data.

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

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

The description implicitly indicates usage (when you need a construction plan), but no explicit guidance on when to use versus alternatives, or prerequisites. No mention of exclusions or when not to use.

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

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

No annotations provided, so description carries burden. It describes a read operation (listing) with optional conditional behavior. Lacks explicit details about auth, rate limits, or side effects, but adequate for a simple list 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 concise sentences (bilingual), front-loaded with EN. Every sentence provides distinct information 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?

No output schema, but description covers return content clearly. For a list tool with one optional param, it provides 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 100% with identical information. Description does not add extra depth beyond what schema already provides.

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

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

Clearly states it lists building-code checks and zoning-rule overrides, with optional slug to add site conditions and verdict. Verb 'list' and 'return' are specific and distinguish from siblings like houki_check.

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?

Explains when to pass slug vs not. Implicitly separates from houki_check, but does not explicitly state when not to use or list alternatives.

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

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

No annotations provided, so description carries burden. It correctly implies a read operation and explains the include_elements parameter behavior. No contradictions.

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

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

Description is bilingual yet concise, with two sentences front-loading English. Every sentence is informative 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?

For a two-parameter tool with no output schema, description explains what is returned (full bim.json with meta and elements) and how to control elements. Lacks detailed output structure but sufficient for basic usage.

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

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

Schema coverage is 100%, but description adds value by referencing list_houses for slug and explaining the default and effect of include_elements, surpassing schema details.

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

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

The description uses a specific verb 'Fetch' and clearly identifies the resource as a house's full bim.json v1. It distinguishes this tool from siblings like get_build_plan or get_product by specifying the BIM data type.

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

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

The description provides a clear context for using the tool and notes the effect of include_elements=false for metadata only. However, it does not explicitly compare with alternatives or state when not to use.

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

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

No annotations provided, so description bears full burden. It indicates it returns full detail, implying read-only, but doesn't explicitly state no side effects, auth needs, or error conditions. 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?

Two concise sentences, bilingual, front-loaded with key info. No wasted words.

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

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

For a simple get-by-SKU tool with one parameter and no output schema, the description lists the returned fields (price, U-value, stock, JAN, successor), which is sufficient. Missing error handling or special notes, but overall complete for this complexity.

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

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

Schema coverage is 100% with 'sku' described as '製品 SKU'. The description adds that the tool operates by SKU but offers no further format or constraints. With full schema coverage, baseline of 3 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?

Description clearly states action: 'Get one product's full detail by SKU' and lists specific fields (price, U-value, stock, JAN, successor). This distinguishes it from siblings like search_catalog (searching) or other get_ 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 explicit guidance on when to use vs alternatives. Though it's the only tool for retrieving a single product by SKU with full details, no exclusions or references to siblings (e.g., search_catalog) are provided.

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

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

No annotations are provided, and the description does not disclose behavioral traits such as read-only nature, authentication requirements, or side effects. It lacks details about whether the operation is safe or has any destructive potential.

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

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

The description is two sentences (English and Japanese), front-loaded with purpose, and efficiently lists the conditions without redundancy or unnecessary words.

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

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

Given the simple input (one slug) and no output schema, the description adequately states what is retrieved but does not mention the return format or structure, leaving some ambiguity for the agent.

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

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

Schema description coverage is 100% (slug parameter has a description). The description adds context about the house, but does not provide additional meaning beyond the schema for the parameter itself.

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

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

The description clearly states it retrieves effective site conditions for a house, listing specific items like zoning, road width, etc. It distinguishes from sibling tools like 'set_site_context' and 'admin_set_site_context' which are write operations.

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

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

The description implies it should be used before 'houki_check' by stating the conditions are 'used by houki_check', but it does not explicitly state when to use vs alternatives or provide exclusions.

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

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

No annotations are provided, so the description carries full responsibility. It does not disclose whether the tool is read-only, whether it modifies any data, authentication requirements, rate limits, or error behavior. The description only states it 'runs the check' but omits crucial context about side effects or dependencies.

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 bilingual sentence, concise and front-loaded. It efficiently conveys the tool's purpose. However, it could be slightly more structured (e.g., explicitly stating output format) without becoming 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?

The tool has no output schema, so the description should describe the return value. It only says 'return pass/fail' without specifying format (e.g., boolean, string, object). It also does not cover error cases (e.g., invalid slug, check failure details). Given the tool's complexity (multiple checks), the description is incomplete for an agent to reliably handle responses.

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 only parameter, 'slug', is described in the schema as '物件 slug' (property slug). Since schema coverage is 100%, the baseline is 3. The description does not add further meaning, such as how to obtain the slug or its expected format, but it also does not mislead. The value is neutral.

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 runs the Japanese Building Standards Act check, listing the specific categories (coverage, FAR, slopes, daylight, ventilation) and that it returns pass/fail. This distinguishes it from sibling tools like get_houki_rules, which retrieves rules rather than executing a check.

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 (e.g., get_houki_rules, get_build_plan). There is no mention of prerequisites, such as requiring a valid house slug or that the house must already exist. The agent is left to infer usage context from the tool name and sibling list.

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

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

No annotations are provided, and the description does not disclose behavioral traits beyond 'list'. It doesn't mention idempotency, pagination, data freshness, or side effects, which are important for a data retrieval tool.

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

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

The description is concise with bilingual text. However, it could be slightly more structured (e.g., separate lines for English and Japanese) without adding fluff.

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

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

Given no output schema and simple parameters, the description lacks context about return format, ordering, limits, or performance characteristics. Incomplete for a tool that likely returns a list of contractors.

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 100%, so the description adds minimal value. It reiterates optional filters with examples, but doesn't clarify format or constraints beyond the schema.

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

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

The description clearly states it lists registered contractors with optional filters (prefecture/trade). It distinguishes from siblings like match_contractors and register_contractor, though it doesn't explicitly differentiate from other list tools.

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

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

No guidance on when to use this tool versus alternatives like match_contractors or register_contractor. The description only states what it does, not when it's appropriate.

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

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

With no annotations, the description carries full burden. It discloses that user houses are excluded by default and that include_user controls inclusion. It also lists the return fields (slug, size, number of elements, bim.json fulfillment rate). However, it does not explicitly state read-only behavior, rate limits, or authentication needs.

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

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

The description is bilingual, leading to redundancy. It could be more concise by merging the English and Japanese content. However, the key information is front-loaded in English, and the structure is acceptable.

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 sibling tools (many house-related operations), the description covers what the tool does, its parameter, and return fields. It could be more complete with pagination or sorting details, but overall it provides sufficient context 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 description coverage is 100% (one parameter fully described). The description adds no new meaning beyond the schema, only reinforcing the parameter's purpose. Baseline score of 3 applies.

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

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

The description clearly states it lists curated public houses (famous buildings, landmarks) and distinguishes from user houses. It differentiates from sibling tools like get_house_bim, create_house, and list_mine by specifying the scope (curated public vs user-created).

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

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

The description explicitly tells when to set include_user=true to include public user houses, and implies that default use is for curated houses only. It does not explicitly mention alternatives or when not to use, but the context is clear enough for an agent to decide.

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

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

No annotations are provided, so the description carries full burden. It discloses admin-only access and the purpose behind fixing addresses for zoning. However, it lacks details on side effects, rate limits, or data freshness, which are important for a list operation.

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

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

The description is bilingual, which adds length but is justified for international users. It is front-loaded with the core purpose, and each sentence adds value: what, why, and access control. No redundant 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?

For a list tool with no output schema, the description explains the purpose and condition of the data but does not mention output fields, pagination, or error conditions. It is adequate for basic usage but missing details that could help an agent handle results 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 coverage is 100% with both parameters described. The description adds no extra meaning beyond the schema, such as formatting or constraints on limit. The admin-only context is already implied by the required admin_token.

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

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

The description clearly states it lists public houses with incomplete addresses for correction, specifying the exact condition (missing town name/placeholder) and admin-only access. It distinguishes from siblings like list_houses and update_house.

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

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

The description implies usage when needing to find incomplete addresses for zoning correction, and notes admin-only restriction. However, it does not explicitly state when not to use or provide alternatives, leaving room for ambiguity among 27 siblings.

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

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

No annotations are provided, so the description must disclose behavioral traits. It indicates the tool requires authentication (Bearer API key) but does not explicitly state it is read-only, describe mutation behavior, or mention error cases. The purpose implies a read operation, but it 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 concise, consisting of two sentences (bilingual) with no wasted words. It front-loads the English explanation, making the purpose immediately apparent. The bilingual text could be considered slightly redundant but is acceptable.

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 output schema, the description provides the core purpose and auth requirement but lacks details on response format, pagination, or what happens on errors. For a simple list tool, this is minimally adequate but leaves 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 and schema description coverage is 100% (vacuously). Per the rule '0 params = baseline 4', this score is appropriate as the description does not need to add parameter information beyond what is already clear.

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 lists products registered by the user ('List products you registered'). It distinguishes from siblings like 'list_houses' by specifying 'you registered', making the scope clear. However, it does not explicitly contrast with similar list tools.

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

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

The description mentions the need for a Bearer API key as a prerequisite, but does not provide guidance on when to use this tool versus alternatives like 'list_houses' or 'get_product'. No exclusions or context for selection are given.

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

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

Without annotations, the description discloses matching logic (trade × location, splitting across builders) and omitting trade behavior. No contradictions, but could mention idempotency 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?

Two sentences plus a translation, front-loaded with verb and resource, every sentence adds unique value. No unnecessary words.

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

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

No output schema, but the description implies a matching result (list of contractors). Could be more explicit about return format, but sufficient for a matching tool with clear inputs and context.

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

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

Schema covers both parameters with descriptions. The description adds value by explaining trade omission matches all trades, which is not in the schema. Adds context for location matching (prefecture or lat/lng+radius) but not explicitly in schema.

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

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

The description clearly states the tool matches contractors to a house by trade and location. It distinguishes from sibling 'list_contractors' by specifying a matching function tied to a specific house.

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

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

Provides context that trade can be omitted to match all trades, and that orders split across local builders. Lacks explicit when-not-to-use or alternatives, but the behavior is clear.

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

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

With no annotations provided, the description carries the full burden. It discloses the tool returns BOM, total, unit price, lead times, and critical path, and implies it is a read-only operation. It lacks details on authentication or side effects, but is still fairly transparent.

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

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

The description is in two sentences (English and Japanese) and front-loads the purpose. Though it packs many details into a single sentence, it remains clear and concise.

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

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

Given the complexity of the tool and lack of output schema, the description explains key outputs (BOM, total, ¥/m², lead times, critical path). It could be more structured about the return format, but it is largely complete.

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

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

Schema description coverage is 100% with the single parameter 'slug' described as '物件 slug'. The main description does not add extra meaning beyond the schema, so baseline 3 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 it provides a catalog-priced cost estimate including BOM, total, ¥/m², lead times, and critical path from BIM takeoff. It uses specific verbs and resources, distinguishing it from siblings like search_catalog or place_order.

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

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

The description indicates when to use this tool: for cost estimates based on BIM takeoff and catalog prices. However, it does not explicitly mention when not to use it or provide alternatives.

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

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

No annotations exist, so the description fully carries the burden. It discloses that references are live (resolved at view time, no duplication), details the two source types and their ref formats, and mentions the mandatory edit_token permission.

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 front-loaded with the main action and then provides details. It is bilingual, which may be necessary, but adds some length. Each sentence earns its place, though slight redundancy could be trimmed.

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 5 parameters (4 required) and no output schema, the description explains the core behavior, source types, permission, and resolution mechanism. It covers most essential context, though error handling or edge cases are omitted.

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 100%, yet the description adds significant value: examples for ref (biruwa, living), expands source enum meanings, explains edit_token provenance, and clarifies slug and room 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 clearly states this tool places a *live reference* into a house, not a copy, and distinguishes two source types (mu and device). It uses specific verbs and resources, making the purpose unmistakable and differentiating it from siblings like create_product.

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

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

The description indicates when to use (to place a live reference, requires edit_token) and implies alternatives (not a copy). However, it lacks explicit when-not-to-use or reference to sibling tools like create_product for actual copies.

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

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

No annotations provided, so description carries full burden. It discloses key trait: does NOT send, only drafts. Also mentions inclusion of spec/inspection list. Does not cover auth, rate limits, or side effects, but for a draft-creation tool, the essential behavior is well communicated.

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

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

Two sentences, front-loaded with key action and constraint. Bilingual version efficient. No wasted 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?

No output schema, but description states draft creation and human action later. Could mention return value (e.g., order ID) but not essential for basic usage. For a simple 3-param tool, it's nearly complete.

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

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

Schema coverage is 100%, baseline 3. Description adds value by indicating sources: trade code from get_build_plan phases.trade, contractor_id from match_contractors/list_contractors. This helps agent fetch correct values, exceeding mere schema repetition.

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 verb (create), resource (DRAFT purchase order), scope (for one trade of a house to a contractor), and distinguishes from sending by explicitly noting draft-only. Sibling tools include creation tools but none for orders, so purpose is unambiguous.

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

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

Context is clear: use for draft orders only, and human sends later. However, no explicit when-not-to-use or alternative tools mentioned. The sibling list includes 'material_quote' which might be related, but no direct comparison.

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 discloses the authentication requirement and self-serve nature, but lacks details on side effects, response format, or idempotency. For a creation tool, this is adequate but not comprehensive.

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

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

The description is two sentences (English and Japanese), front-loaded with the purpose and key requirements. Every sentence provides essential information without redundancy.

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

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

Given 9 parameters (1 required, no output schema), the description covers the most critical aspects: authentication, trades, and location. The schema descriptions handle the remaining parameters in detail. The description provides a good overview, though could briefly mention other parameters for completeness.

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

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

Schema description coverage is 100%, so baseline is 3. The description adds value by explaining the trades parameter ('trade codes or all') and grouping location alternatives ('via prefectures and/or lat/lng+service_radius_km'), which goes beyond the schema's individual 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 explicitly states 'Register a contractor (supply side, self-serve)', clearly indicating the verb (register) and resource (contractor). It distinguishes from sibling tools like list_contractors and match_contractors by focusing on creation. The parameter hints (trades, location) add specificity.

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

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

The description mentions the authentication requirement ('Requires Bearer API key') and provides guidance on location parameters, but does not explicitly state when to use this tool over alternatives or when not to use it. No exclusions or alternative tools are mentioned.

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

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

No annotations exist, so the description carries full burden. It discloses that the operation is a soft delete (non-destructive), requires authentication, and is limited to own products. This provides sufficient behavioral context for an agent.

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 covering action, auth requirement, scope, and deletion type. No wasted words, and it is 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, the description lacks information about the expected return value or confirmation of success. It explains what happens (soft delete) but not what the agent receives in response, which is a minor gap for a simple action tool.

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

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

With 100% schema description coverage, the schema already documents that 'sku' is required. The description adds meaningful context: the sku must belong to a product the user created, which goes beyond the schema's simple 'SKU to retract' explanation.

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 'retire' and resource 'product', and specifies that it is a soft delete (discontinue) operation. It distinguishes from siblings like 'delete_zoning_rule' by focusing on product discontinuation, and from 'update_product' by emphasizing retirement.

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

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

The description provides clear context: requires Bearer API key, only for self-created products, not for official SKUs or others' products. It implies when to use (soft delete) but does not explicitly mention alternatives or when not to use.

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

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

No annotations are provided, so the description carries full burden. It only repeats the filtering criteria from the schema without disclosing behavioral details such as whether it performs partial or exact matching (partially covered in param descriptions), result format, ordering, or side effects. Minimal transparency beyond the schema.

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

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

The description is a single sentence that front-loads the core purpose in both English and Japanese. It is concise but includes redundant bilingual content; however, it still communicates the essential functionality without wasted words.

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

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

Given the tool has 4 well-described parameters and no output schema, the description covers the input side adequately. However, it lacks details about the output (e.g., return format, ordering, pagination) which is important for an AI agent. The 3,900+ SKU count adds context, but overall completeness is average.

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

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

Schema description coverage is 100%, and the description adds minor extra context (e.g., 'partial match' for q, 'exact match' for brand/category). The baseline is 3, and the description does not significantly enhance parameter understanding beyond the schema.

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

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

The description clearly states that the tool searches a building-materials catalog by keyword, brand, or category, with a specific resource ('catalog') and filtering dimensions, distinguishing it from sibling tools like get_product or create_product.

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 searching products, but does not explicitly state when to use it versus alternatives (e.g., get_product for a specific SKU, list_mine for user items). No exclusions or when-not-to-use guidance is provided.

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

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

With no annotations, the description carries the burden of transparency. It discloses that the tool toggles forkability, requires an edit_token (auth), and notes the default state. This is sufficient for a simple boolean toggle.

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

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

The description is extremely concise: two bilingual sentences with no wasted words. The main purpose is front-loaded, immediately informing the agent.

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

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

Given the tool's simplicity (3 required params, no output schema, no nested objects), the description covers everything needed: purpose, required parameters, effect, and default. It is complete.

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

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

Schema coverage is 100% with descriptions for all parameters. The description adds value by explaining the meaning of forkable (allow/forbid), the requirement for edit_token, and the default behavior, going beyond the schema.

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

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

The description clearly states the verb 'allow or forbid' and the resource 'forking a house', making the purpose immediately obvious. It distinguishes from sibling tools as none deal with forking.

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

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

The description mentions the requirement for an edit_token and the default behavior (forkable=true), giving clear context. However, it does not explicitly state when not to use this tool or mention alternatives.

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

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

No annotations are provided, so the description carries the full burden. It discloses partial update behavior, authentication requirement, and return of the re-run verdict, but does not mention 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 concise with two short paragraphs (English and Japanese). Every sentence is essential and informative, with no unnecessary 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?

Covers purpose, authentication, return value, and typical use case. Parameter details are in the schema. Could mention errors or output format, but adequate given 100% schema coverage.

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 100% with descriptions for all parameters. The description adds context that only provided fields are updated, but does not significantly enhance meaning beyond the schema.

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

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

The description clearly states the verb 'override' and the resource 'house's site conditions', specifically for houki_check. It distinguishes from the sibling 'houki_check' and implies a separate admin variant exists.

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

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

The description indicates when to use (fix false NGs from defaults) and the need for an edit_token, but does not explicitly mention alternatives or when not to use. Context is clear.

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

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

No annotations are provided, so the description carries full burden. It honestly discloses that toggling requires an edit_token, and that private=true only hides from listing while preserving direct link. This covers key behavioral traits. Could mention if any other side effects (e.g., search indexing) exist, but it's sufficient.

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, with a bilingual format that front-loads the English summary. Every sentence adds necessary information: purpose, required token, effect, and example use case. No wasted words.

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

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

Given the tool has only 3 simple parameters, no output schema, and relatively simple behavior, the description is complete. It explains what the tool does, under what conditions (needs edit_token), the effect, and a typical use case. An agent can correctly invoke this 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?

Input schema has 100% coverage with descriptions for all 3 parameters. The description adds value by specifying that edit_token comes from create_house and explaining the effect of private (true=unlisted). This goes beyond the schema.

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

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

Description clearly states the tool toggles a house's public listing on/off, specifying that private=true hides it from listing but direct link remains. It also gives a use case (culling low-score houses in evolution loops), which distinguishes it from sibling tools like update_house or list_houses.

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 mentions the mandatory edit_token (from create_house) and explains the effect of private=true. It implies usage context (needs token, used for culling), but does not explicitly state when not to use or provide alternatives, which would be helpful.

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

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

The description discloses that the tool returns a re-run houki verdict, is versioned each save, and that changing project_type alters cost calculations. Since no annotations exist, the description carries full burden; it covers key behaviors well but does not mention permission requirements beyond edit_token.

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 front-loaded with English, then repeated in Japanese. It is clear and structured, but the bilingual content adds length. No extraneous sentences; each sentence provides value.

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

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

Given 6 parameters, nested objects, and no output schema, the description explains return value (houki verdict), versioning, and the iterative workflow. It is thorough enough for an AI agent to understand the tool's full behavior and usage pattern.

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

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

All 6 parameters have descriptions in the schema, and the description adds significant extra context: elements is a full replacement, project lists subfields with effects (e.g., renovation cost), edit_token must come from create_house, note is a 500-char memo, and elements_json is for strict-schema clients. Schema coverage is 100%.

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

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

The description explicitly states it updates an existing house's bim.json by swapping elements or patching project meta, and returns a re-run houki verdict. It clearly distinguishes from sibling tools like get_house_bim (read) and create_house (create).

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 mandates edit_token (from create_house) and outlines a workflow: get current bim, edit, update, check verdict. It explains when to use elements vs project and the effect of changing project_type on cost. However, it lacks explicit when-not-to-use or alternative tool references.

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 authentication requirements, ownership restriction, and partial update behavior ('overwrite specified fields'). However, it omits details like error handling, idempotency, or side effects. Score 3 is appropriate for adequate but not exhaustive 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 concise and front-loaded with key information (verb, resource, auth, restriction). The bilingual structure adds length but does not detract. Every sentence adds value. Slight improvement possible by merging language versions.

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 17 parameters, no output schema, and no annotations, the description covers authentication, ownership, and partial update. However, it lacks information on return value, error cases, and whether SKU is immutable. The tool is fairly well described but not fully complete for a complex update operation.

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

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

Schema coverage is only 18%, so description must compensate. It adds that only provided fields are overwritten, clarifying partial update semantics. However, it does not explain individual parameters beyond what schema already states. This marginally improves understanding but leaves many parameters undocumented.

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

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

The description clearly states the action ('Update fields'), the resource ('a product you created'), and constraints ('your SKUs only'). It distinguishes from sibling tools like 'create_product' (creation) and 'retire_product' (retirement). The bilingual format reinforces the intended scope.

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

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

The description explicitly states when to use (update owned products) and prerequisites (Bearer API key, product must be self-created). It implies not to use for other users' or official SKUs. However, it does not name alternative tools for updates or explicitly state when NOT to use.

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

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

No annotations exist, so the description must convey behavioral traits. It states the tool requires admin authentication and applies changes to all matching houses, but does not disclose upsert semantics (e.g., overwrite vs. merge), potential side effects, or error conditions. This provides only moderate transparency.

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

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

The description is extremely concise, with two sentences covering purpose, scope, and admin requirement in both English and Japanese. Every word contributes value 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?

Given the tool's complexity (11 parameters, no output schema), the description adequately explains the tool's effect and prerequisites but fails to describe the return value or upsert behavior (e.g., what happens on conflict). This leaves some gaps for an agent to safely 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?

Schema coverage is 100%, so the baseline is 3. The description groups parameters by category but does not add meaning beyond the existing schema descriptions for each parameter. No additional syntax, constraints, or nuances are provided.

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

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

The description clearly states the tool adds or updates a zoning regulation rule, specifying the types (coverage/FAR/slope/height limits) and its effect on houses matching a profile and zoning. This distinguishes it from sibling tools like delete_zoning_rule and get_houki_rules.

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

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

The description mentions 'admin only (admin_token)' as a requirement, but does not provide explicit guidance on when to use this tool versus alternatives (e.g., delete_zoning_rule for removal). It implies usage for creating or updating rules but lacks explicit comparisons or exclusions.

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

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

No annotations are provided, so the description carries the full burden. It discloses the need for a Bearer token and the return value (email), but does not specify error behavior (e.g., invalid or missing key) or rate limits.

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

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

The description is two sentences (bilingual), clear and front-loaded. Some redundancy due to duplicate languages, but not 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 simplicity of the tool (no output schema, no parameters), the description adequately covers the input requirement (Bearer token) and output (email). Missing error handling details, but not critical for this tool.

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

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

The tool has 0 parameters and schema coverage is 100%, so the description adds no parameter information, but none is needed. Baseline for 0 parameters is 4.

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

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

The description clearly states the tool verifies API key authentication and returns the account email, which is a specific verb-resource combination. It distinguishes from sibling tools (none of which are auth-related).

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 checking auth status and mentions it works from Web/CLI. It does not explicitly state when not to use or provide alternatives, but for a simple auth check this is adequate.

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