civilquants

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

Discloses authentication requirement and paid tier restriction. Explains behavior of freeboard parameter. Annotations set readOnlyHint: true, consistent with a computation tool. No contradiction.

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

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

While the description is lengthy, it efficiently packs essential information about variants, standards, parameters, and deliverables. Each sentence adds value, though slight tightening could improve 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's complexity (three structural variants, multiple standards, many parameters), the description is thorough. It covers variants, presets, standard mappings, parameter constraints, and deliverables. Output schema exists for return values.

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?

Adds significant meaning beyond the schema: provides example values with ranges (stem_height=6 m (2–15)), defaults, and relationships (freeboard vs retained_height). The description compensates for the schema's limited descriptions and adds engineering context.

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 computes a Bill of Quantities for anchored retaining walls, specifically noting it's the only wall family member with pre-stressed ground anchors. It distinguishes from the sibling tool compute_cantilever_wall by mentioning it as a free-tier alternative.

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

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

Explicitly states it's paid tier only and warns about TIER_INSUFFICIENT error for unauthenticated calls. Provides the free alternative compute_cantilever_wall. Includes example params and an example call. Clarifies when to use freeboard vs retained_height.

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

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

The description mentions that the tool is free tier with limitations, anonymous callers are welcome, and omitted parameters use sensible defaults. It does not contradict the readOnlyHint annotation, as the tool performs calculations without mutating data. This adds valuable context beyond annotations.

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

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

The description is moderately sized and contains essential information: tier restrictions, configuration options, example call, and deliverables. It is front-loaded with critical constraints. A slightly more structured format could improve readability, but it remains efficient.

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

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

Given the tool's complexity (many parameters, nested object, multiple standards) and the presence of an output schema, the description is fairly complete. It covers free tier limitations, example usage, and defaults. It could have elaborated on the meaning of each output mode, but overall it is sufficient.

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

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

Despite schema description coverage being 0%, the description compensates by explaining key parameters like tank_length, crate_width, and crate_height with default ranges. It states that omitted parameters use defaults, but does not describe all parameters individually. This is adequate but not fully comprehensive.

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

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

The description clearly states the tool computes a stormwater attenuation tank Bill of Quantities. It specifies two tank configurations (crates or pipes) and excavation types, distinguishing this tool from sibling tools that compute other civil engineering structures.

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 that only the MMHW standard is available in the free tier, while CESMM4, NRM2, and SMM7 require a paid tier. It includes an example call and explains the deliverables parameter. However, it does not provide explicit guidance on when not to use this tool versus its 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?

Discloses authentication requirement and error behavior (TIER_INSUFFICIENT), output formats (xlsx, dxf, pdf), and defaults behavior. Adds value beyond the readOnlyHint annotation by detailing access constraints and deliverable options.

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?

Overly verbose; includes extraneous taxonomy details about structural families (SEVENTH member, FIFTH leaf) and coding references that are not needed for an AI agent. Core information should be more front-loaded 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?

Provides a good overview of the tool's complexity, structural forms, and deliverables, but lacks detailed descriptions for many parameters. Adequate for a complex tool given presence of output schema and default parameter values.

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?

Adds meaning with example parameter ranges (wall_length_m, retained_height_m, embedment_below_formation_m) and explanations of the bored_pile_form enum. However, schema coverage is low (25%) and many parameters remain undescribed; the description partially compensates but is not exhaustive.

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

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

The description clearly states the tool computes a BoQ for bored pile retaining walls and distinguishes from the free-tier alternative compute_cantilever_wall. However, the purpose is somewhat buried in verbose taxonomy about structural families and coding references.

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 explicit guidance on paid tier requirement ('Calling this without an authenticated CivilQuants account returns TIER_INSUFFICIENT'), alternative free tool (compute_cantilever_wall), and gives example parameters and calls. Lacks explicit when-not-to-use but provides sufficient context.

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

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

The description contradicts annotations: readOnlyHint is true, but the tool performs computation (returns BoQ, drawings) and requires paid authentication. Description states TIER_INSUFFICIENT error, indicating a write/compute operation, not 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?

Long description (multiple paragraphs) with detailed examples. Front-loaded with important paid tier warning, but could be more concise. Some redundancy (e.g., repeated info on headwalls).

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 complexity and output schema existence, description is comprehensive: explains components, standards, optional deliverables, and defaults. Covers most aspects needed for 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 low (25%), but the description adds value by explaining defaults and deliverable mechanism. However, it does not enumerate all parameters; the schema itself has some descriptions. Overall, adds moderate insight beyond schema.

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

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

The description clearly states it computes a precast concrete box culvert BoQ, specifying the resource (box culvert run) and verb (compute). It distinguishes from siblings by naming compute_manhole as a free-tier alternative.

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

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

Explicitly mentions paid tier requirement and free-tier alternative. Provides example parameters and call, and notes when to use (for box culvert BoQ) and when to avoid (if not paid).

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

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

The description adds significant behavioral context beyond the readOnlyHint annotation: free tier restrictions, anonymous caller support, default parameter behavior, freeboard back-calculation, and deliverables format. No contradiction with annotations; the description enriches the agent's understanding of side effects and limitations.

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

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

The description is a single paragraph with all essential information, front-loading free tier info and purpose. It is clear but could benefit from more structure (e.g., bullet points for parameters) to improve scanability. Every sentence adds value, with minimal 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 complexity (5 top-level parameters, nested params object with many fields, output schema present), the description covers core functionality, tier constraints, example usage, and key parameter behaviors. It lacks coverage of error cases or behavior when parameters are out of range, but overall is adequate for the complexity level.

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

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

The schema has 0% parameter description coverage, so the description must compensate. It adds meaning for key parameters like stem_height with range examples (2–8 m), stem_thickness_top (0.2–0.6), stem_thickness_bottom (0.25–0.9), freeboard (clearance), and deliverables (any subset of xlsx, dxf, pdf). However, many other parameters (toe_length, heel_length, etc.) are left undocumented, so compensation is partial.

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

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

The description clearly states the tool computes BoQ for an in-situ reinforced concrete cantilever retaining wall, specifying components like toe, heel, stem, excavation, etc. It distinguishes from sibling tools by focusing on 'cantilever' wall, which differentiates from other retaining wall types like gravity or counterfort walls.

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 on when to use (cantilever wall BoQ) and tier limitations (free tier only for MMHW). It includes an example call with parameters. However, it does not explicitly state when not to use or suggest alternatives among sibling tools like compute_gravity_wall or compute_counterfort_wall, so it lacks 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?

The description discloses that authentication is required for paid tier, that it returns deliverables like xlsx/dxf/pdf conditionally, and that it is read-only (consistent with annotations). It adds context about the return format and tier limitations beyond the readOnlyHint.

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 long and includes many implementation details (e.g., discriminator pattern, companion assembly history) that are not essential for an agent. It could be more concise while retaining 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?

The description covers authorization, parameter defaults, example calls, deliverable options, and standards. Given the tool's complexity (4 parameters, nested objects, enums), this provides all necessary context for correct invocation without needing external lookup.

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?

Although schema description coverage is only 25%, the description compensates by explaining each parameter's role, providing example values, and clarifying defaults and enum meanings (e.g., material families, use descriptions).

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

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

The description clearly states it computes BoQ for carrier pipe runs according to four standards (CESMM4, NRM2, MMHW, SMM7) with specific class references. It distinguishes itself from siblings by mentioning the companion tool 'connection_to_existing' and the free-tier alternative 'compute_manhole'.

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 'Paid tier only' and provides an alternative free tool, 'compute_manhole'. It also explains that omitted parameters use sensible defaults and gives example parameter calls, guiding effective usage.

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

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

Discloses paid tier requirement, authorization failure response, watermarking for free tier, and deliverables behavior. Annotations have readOnlyHint: true, and description adds behavioral context beyond that.

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?

Somewhat verbose but front-loaded with key information. Every sentence is informative. Could be slightly more concise, but structure is logical.

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 all aspects: purpose, usage, alternatives, authentication, parameters example, deliverables, and standards. Despite high complexity, the description provides complete guidance.

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 25%, but description explains catalogue-driven sizing, example params, and that omitted params use sensible defaults. It adds context for parameters like size and standard 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 computes a BoQ for a precast concrete catchpit/silt trap, using BS 5911-3 and several standard methods. It distinguishes from manholes by the silt-sump geometry and typical position upstream of an interceptor.

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

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

Explicitly states paid tier and provides free-tier alternative compute_manhole. Gives example params and call, and context for when to use (upstream of petrol/oil interceptor in forecourt drainage).

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

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

Beyond the readOnlyHint annotation, the description discloses authentication and tier requirements, the behavior of omitted parameters (defaults), and the ability to receive deliverables with one-shot download URLs. It also explains the rendering standards and the free/paid tier differences (watermarked vs. full).

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 well-structured and front-loaded with the most important information (paid tier, core functionality). It is informative but somewhat lengthy; every sentence serves a purpose, though some details (e.g., the list of standards) could be more 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 (nested parameters, multiple standards, optional deliverables, authentication) and the presence of an output schema, the description covers the essential aspects for tool selection and invocation. It provides examples and explains the shared envelope concept, but could further clarify the relationship between parameters and defaults.

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 value by explaining the services array structure, providing example parameter values and ranges, and clarifying that omitted parameters use sensible defaults. The input schema itself has descriptions for many parameters, so the description complements rather than replaces schema 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 tool computes a BoQ for a shared utility trench with multiple services, following NJUG Volume 1 and multiple standards (CESMM4, NRM2, MMHW, SMM7). It distinguishes from the free-tier alternative compute_manhole and implies differentiation from compute_single_service_run by emphasizing the shared envelope.

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 the paid-tier requirement and suggests the free-tier alternative compute_manhole. It provides example parameters and a call example, but does not explicitly state when to use this tool over other trench-related siblings (e.g., compute_single_service_run).

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

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

Beyond readOnlyHint annotation, the description discloses tier restrictions, behavior when not authenticated, that it computes BoQ (not modifies data), and details on deliverables. It adds significant context about the standards routing and output modes, though it could slightly improve by explicitly stating no write operations occur.

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

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

The description is dense but well-organized: starts with tier warning, then systematically covers tool purpose, standards, parameters, unit, sibling tools, example, and deliverables. Every sentence adds value; 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?

Very comprehensive for a complex tool, but existing_asset_id parameter is not explained in the description (only mentioned in schema). The description covers connection types, standards, deliverables, and tier info well, but omits guidance on when and how to use the existing_asset_id field.

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 low (25%), but the description compensates by explaining connection_type as a discriminator with standard codes, method as non-code-affecting, and provides example call with diameter range and sensible defaults for omitted parameters. It adds engineering context missing from 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 computes an extra-over connection BoQ item for drainage, enumerates connection types, and distinguishes from sibling compute_manhole and carrier_pipe_run. It provides a specific verb ('computes') and resource ('Connection to Existing drainage BoQ').

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

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

Explicitly states paid tier only with a free alternative (compute_manhole), mentions when not to use (tier insufficient), and provides context on when to use this versus siblings like carrier_pipe_run. Also includes prerequisites (authenticated account).

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

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

Discloses tier requirements, error responses (TIER_INSUFFICIENT), watermarking, and deliverable behavior beyond annotations. Annotations already provide readOnlyHint=true, so the bar is lower; description adds useful context about payment and output restrictions. No contradictions with annotations.

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

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

The description is relatively long but well-structured with clear sections. Front-loaded with critical tier information. Each sentence adds value, though could be slightly condensed. No redundant repetition of schema.

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

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

Given the complexity of the tool (many nested params, multiple standards, deliverables), the description covers tier, error handling, alternatives, parameter usage, standards, and output options. Output schema exists, so return value explanation is not needed. Complete for effective tool selection and 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 20%, but the description adds meaning by explaining parameter usage like freeboard vs retained-height, deliverables format, and example calls. Nested params object has its own rich schema descriptions for enums. The description provides context that the schema alone does not.

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 'Compute Counterfort Retaining Wall BoQ', uses specific verb 'compute' and resource, and distinguishes from sibling tools by explicitly naming the free-tier alternative compute_cantilever_wall and referencing other wall types for height ranges. The purpose is clear and unambiguous.

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

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

Explicitly states when to use (4-10m retained heights) and when not (above cantilever-economic range, below anchored-wall range). Provides explicit alternative (compute_cantilever_wall for free tier) and mentions prerequisites (CivilQuants account). Comprehensive usage guidance.

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

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

Annotations already declare readOnlyHint: true. The description adds concrete details: authentication requirement, tier insufficiency error, and behavior of deliverables (one-shot download URLs). No contradiction.

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

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

The description is verbose, including extensive standards references and variant presets that may not be essential for an AI agent to select the tool. However, it is front-loaded with key info (paid tier, 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?

Covers purpose, constraints, alternatives, examples, and deliverables option. Output schema exists, so no need to detail return values. Provides sufficient context for an agent to invoke correctly.

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

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

Schema description coverage is low (25%). The description adds value by detailing parameter ranges (e.g., run_length_m 1-1000) and explaining side_slope_h_per_v meaning. It also notes that omitted parameters use engineering defaults.

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

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

The description clearly states the tool's purpose: 'Linear primary measurement of an open earthwork drainage channel' and outputs a BoQ. It distinguishes from siblings by mentioning it's the second member of the drainage_ancillaries leaf and contrasts with the free-tier alternative compute_manhole.

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

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

Explicitly states paid-tier requirement, provides sign-up link, and directs to free alternative compute_manhole. Also gives example parameters and a sample call, plus notes on omitted parameters using defaults.

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

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

Annotations declare readOnlyHint=true, meaning no side effects. The description adds that the tool requires authentication for paid tier, returning a specific error otherwise. It also mentions optional deliverables. This adds useful behavioral context beyond the annotation.

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

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

The description is long but packed with relevant information. It begins with the tier warning and then provides definitions, defaults, and examples. Some redundancy could be trimmed (e.g., repeating standard references).

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 (many parameters, output schema exists), the description covers usage context, standards, example call, and deliverables. However, it misses comprehensive parameter documentation and could better describe return values when output schema is present but not detailed in 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?

The input schema has 15+ parameters with no description coverage (0%). The description only mentions three example parameters and their ranges, lacking explanation for the majority. It states omitted parameters use defaults, but without detailing them, the agent cannot understand their purpose or values.

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?

Title and description clearly specify the tool computes BoQ for 'highway pavement edge drain' per HD 33/16, with a detailed definition. It distinguishes itself from siblings like compute_french_drain by mentioning highway-specific defaults and standards.

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

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

Explicitly states 'Paid tier only' and points to free-tier alternative compute_manhole. Provides example parameters and call format, helping the agent decide when to use this tool versus other drain computation 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?

The description goes beyond the readOnlyHint annotation by detailing tier requirements, error conditions, delegation to end_area_earthworks engine, auto-computation of topsoil strip, and support for optional excavation. It also explains the inheritance of rendering invariants and the one-shot download URL mechanism for deliverables.

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 well-structured with clear sections: tier warning, core functionality, example, and deliverables. It front-loads critical information (paid tier, alternative) and uses bullet-like phrasing. However, it is somewhat verbose and could be trimmed without losing substance.

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 (many parameters, nested objects, sibling tools), the description covers the main workflow, tier restrictions, and deliverables. It explains the delegation and core features. However, it lacks detailed parameter descriptions for most parameters, relying on defaults and an example. The existence of an output schema reduces the need for return value explanation, but parameter descriptions are still lacking.

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

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

The schema has many parameters with 25% coverage, but the description adds value by explaining crest_width_m, side_slope_h_per_v, and strip_envelope_offset_m with examples and sensible defaults. However, it does not explain the meaning of most other parameters like method, bulking, material classes, which are critical for proper use. The example call helps but is insufficient for full 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 it computes an embankment cross-section BoQ, explicitly distinguishing from the free-tier alternative compute_end_area_earthworks. It specifies the geometry-driven approach per MMHW Series 600 and lists key parameters, making the purpose 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?

It explicitly states it is paid-tier only and directs to the free-tier alternative compute_end_area_earthworks. It provides example parameters and a full example call, enabling correct invocation. It also explains when to omit parameters and how to request deliverables.

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

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

Annotations provide readOnlyHint=true, and the description adds significant behavioral context: computation details (integration method, bulking, shrinkage), tier limitations, rendering behavior across standards, and deliverable options. No contradiction with annotations.

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

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

The description is a dense, single paragraph with many clauses and details. It could be structured into sections (purpose, usage, examples, limitations) for better readability. While informative, it lacks 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's complexity (nested objects, many params, output schema exists), the description covers calculation method, standards, deliverables, tier limitations, example call, and defaults. It doesn't explain return values, but output schema fills that gap. Fairly 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 has detailed parameter descriptions (e.g., bulking, cross_sections) covering 25% of parameters, plus enums with standard material classes. The tool description adds overall context (example params, integration method) but does not significantly enhance individual parameter 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 explicitly states the tool computes end-area earthworks BoQ, specifies the standard (MMHW), method (Simpson's Rule), and provides example parameters and deliverables. It clearly distinguishes from sibling compute tools by naming the specific earthworks and standard.

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: free tier vs paid tier, which standards are supported, anonymous callers welcome, and example call with parameters. However, it does not explicitly state when to use this tool versus sibling compute tools for different structures, which is a minor gap.

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

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

Annotations declare readOnlyHint=true, which is consistent with a computation tool. The description adds context about authentication requirements, tier insufficiency errors, and the one-shot download URLs for deliverables, going beyond the annotations.

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

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

The description is comprehensive but lengthy; however, every sentence provides essential information. It is well-structured, starting with the critical usage constraint and then detailing the build-up layers, standards, and example calls.

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 (many parameters, multiple standards, output modes, deliverables), the description covers key aspects: purpose, usage constraints, parameter defaults, and output options. The presence of an output schema partly reduces the need to describe return values in detail.

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?

While schema description coverage is 25%, the description adds meaningful context for parameters, such as traffic category mappings to DMRB CD 226, default dimensions for an urban access road, and the effect of omitted parameters. This compensates for the lack of full schema descriptions.

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

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

The description clearly states that the tool computes a flexible pavement build-up BoQ, including optional layers, standards, and traffic categories. It distinguishes itself from sibling tools like compute_rigid_pavement and compute_end_area_earthworks by specifying 'flexible pavement' and mentioning the free-tier alternative.

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

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

The description explicitly states 'Paid tier only' and provides the alternative compute_end_area_earthworks for free-tier users. It gives example parameters, default values, and notes when explicit thicknesses are needed (e.g., design traffic >30 msa).

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

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

Annotations set readOnlyHint=true, consistent with description (no data modification mentioned). Description adds useful context: requires authenticated account, returns TIER_INSUFFICIENT error without it, and delivers download URLs for deliverables. 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 well-structured: starts with tier info, then technical description, then example, then deliverables. Front-loaded with critical details. Slightly long but earns its length with relevant 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?

Covers tier, alternative, standards (CESMM4, NRM2, MMHW, SMM7), example call, default behavior, and deliverables. With output schema present, return values need not be detailed. Sufficient for agent to understand and invoke correctly.

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

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

Schema description coverage is 0% per context, but description only provides example values for three parameters (pipe_internal_diameter_mm, pipe_wall_thickness_mm, drain_length) without explaining others. 'Omitted parameters use sensible defaults' offers minimal guidance. Does not compensate for lack of schema descriptions.

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

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

The description clearly states it computes a French drain BoQ, provides technical details (perforated drain, granular-filled trench, geotextile wrap), and distinguishes from sibling tool compute_manhole as a paid-tier alternative. The purpose is specific and unambiguous.

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

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

Explicitly states 'Paid tier only' and mentions the free-tier alternative compute_manhole. Includes example parameters and call, and explains when to use the tool versus alternatives. Provides clear context for 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?

The description extensively describes behavioral traits: paid tier, authentication, output options (deliverables: xlsx, dxf, pdf), default parameters, and the discriminator pattern for structural forms. It adds context beyond annotations by explaining the paid tier error and output features. However, it does not explicitly confirm read-only behavior, and annotations state readOnlyHint=true, which may be contradictory given the tool creates new WorkCategory entries.

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 excessively long (over 500 words) with dense technical details about structural forms, codes, and historical context. While informative, it lacks conciseness; a shorter version would be more efficient for an AI agent to parse. Key information is front-loaded (paid tier, authentication), but the latter half is 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's complexity (four forms, many parameters, paid tier, multiple output modes), the description covers virtually all relevant aspects: authentication, alternative tool, parameter examples, defaults, output deliverables, codes, and discriminator patterns. It is extremely thorough and leaves few gaps for an agent to infer.

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

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

The description adds value beyond the schema by providing example parameters and call, listing defaults for key parameters (wall_height=3m, wall_length=25m, basket_length_m=2m), and explaining the deliverables parameter. Schema coverage is low (25%), but the description compensates with examples and practical usage notes, though it doesn't detail every 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 states the tool computes a Bill of Quantities for a modular gabion retaining wall. It distinguishes from siblings by being the first non-concrete retaining structure and explicitly names the free alternative compute_cantilever_wall. The four structural forms and eight variant presets are detailed, leaving no ambiguity about what the tool does.

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 starts with 'Paid tier only' and specifies authentication requirements, explicitly warning about TIER_INSUFFICIENT error. It names the free-tier alternative compute_cantilever_wall. It also provides example parameters and a call, guiding when to use this tool versus alternatives.

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

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

Annotations declare readOnlyHint: true, so the tool is stateless. The description adds context: describes computation details (inclusions like excavation, drainage), output deliverables (Excel, DXF, PDF), and tier behavior (TIER_INSUFFICIENT error). No contradictory behavior disclosed. Slight verbosity but adds value beyond annotation.

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

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

Description is lengthy and includes internal implementation details (e.g., '13th use of the classed-then-legacy pattern') that are irrelevant for an agent. Front-loaded with tier info, but overall verbose. Could be more concise while retaining essential 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 complexity (4 top-level params, nested params, output schema exists), the description covers tool purpose, inputs (including defaults and ranges), outputs (deliverables), and usage context. Output schema handles return details. Some param descriptions missing, but overall adequate for an experienced 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 only 25% (low). The description adds meaning for key parameters like stem_height, stem_thickness_top/bottom (with ranges) and mentions variant presets. However, many parameters are not explained (e.g., toe_length, heel_length, back_profile, etc.). The example call helps but incomplete compensation for low coverage.

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

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

The description clearly states it computes a mass concrete gravity retaining wall BoQ, specifying wall type, cross-section, and materials. It explicitly differentiates from the sibling tool compute_cantilever_wall as a free-tier alternative, and mentions variants. The verb 'compute' and resource 'Mass Concrete Gravity Retaining Wall BoQ' are specific.

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

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

Explicitly states paid tier requirement and provides the free-tier alternative (compute_cantilever_wall). Includes example parameters and example call. Describes when to use, including variant presets and standard codes. Clear guidance on deliverables and how to pass them.

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

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

The description discloses behavioral traits such as free tier restriction, anonymous caller acceptance, and use of sensible defaults. While annotations already indicate readOnlyHint=true, the description adds context about tiers and deliverables. It does not contradict annotations.

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

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

The description is relatively long but well-structured with front-loaded tier information and an example call. Almost every sentence adds value, but it could be slightly more concise by grouping standard-related info. Still, it earns a 4 for 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 (many parameters, nested objects, output schema exists), the description covers essential aspects: tier limitations, an example call, deliverables, and component description. It does not need to explain return values due to output schema. It is nearly complete for an agent to invoke correctly, though more parameter details would help.

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

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

Schema description coverage is 0%, so the description carries the burden. It adds meaning by explaining the composite nature of the gully and providing example parameters with ranges (e.g., pot_internal_diameter_mm 300–750). However, it does not describe all 24 parameters individually, leaving many undocumented. Baseline 3 is appropriate as it partially compensates.

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

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

The name and title clearly indicate a tool for computing a gully with connection BoQ. The description explains it is a composite drainage inlet with specific components (gully pot, grating, kerb outlet, connection drain), and the mention of four-standard rendering with sub-codes distinguishes it from sibling tools like compute_catchpit or compute_highway_drainage_channel.

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 that the free tier only supports MMHW, and that other standards require a paid tier. It provides an example call and mentions that omitted parameters use defaults. However, it does not explicitly compare this tool to siblings or state when to use it instead of alternatives like compute_catchpit or compute_manhole.

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

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

Discloses paid tier enforcement, authentication requirement, and the dual-quantity behavior across four standards. Does not contradict annotations (readOnlyHint is appropriate for a computation 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?

Front-loaded with tier info and alternative, then logically structured: behavior, standards, parameters, example. Every sentence adds value; 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?

Covers tier, standards, parameter semantics, example call, deliverables, and sibling context. Thoroughly equips an agent to select and invoke the tool correctly.

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

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

Despite low schema coverage (25%), the description provides extensive parameter details: ranges, defaults, engineering rationale, geometry interpretation, and examples. Fully compensates for schema 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 clearly states it computes extra-over measurement of hard material in trench excavation, specifies the dual-quantity nature (length and volume), and distinguishes from the free-tier alternative compute_manhole.

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

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

Explicitly states paid tier requirement and provides free-tier alternative compute_manhole. Also notes SMM7's deemed-included behavior, guiding appropriate usage.

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

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

Beyond the readOnlyHint annotation (which indicates no state modification), the description discloses pricing tiers, output modes (summary, boq, etc.), deliverables (xlsx, dxf, pdf), and watermarks for free tier. This adds significant 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 packed with useful information but is somewhat long and dense. Front-loading key points (free tier, standard restriction) is effective, though some technical details could be organized more clearly.

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

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

Given the complex nested input schema (4 top-level params, many sub-params) and 0% schema description coverage, the description provides essential context (standards, outputs, example) but lacks detailed parameter explanations. Output schema exists but is not shown, so return values remain partially 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?

The schema has 0% description coverage, but the description compensates with an example for three key parameters (pipe_internal_diameter_mm, pipe_wall_thickness_mm, invert_below_apron_m) and notes that omitted parameters use defaults. However, many parameters (e.g., cover_mm, concrete_grade) are not explained, leaving 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 explicitly states it computes a reinforced concrete outfall headwall BoQ, detailing components (back wall, wing walls, apron, scour protection) and standards (CESMM4, NRM2, SMM7, MMHW). This clearly distinguishes it from sibling tools like compute_headwall_attenuation_outlet and compute_headwall_precast.

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 guidance: free tier for MMHW, paid for others; example params and full call; defaults for omitted parameters. It does not explicitly state when not to use this tool versus alternatives, but the context of headwall type is implicit.

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

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

The description reveals that the tool requires authentication and is a paid service, returning a TIER_INSUFFICIENT error otherwise. It mentions the default supply route (CONTRACTOR_INSTALL_PC_SUPPLY) and the ability to request deliverables like xlsx, dxf, pdf. While the annotations indicate readOnlyHint=true, the description does not contradict it and adds context about billing and output generation. It lacks explicit mention of side effects or state changes, but overall provides good behavioral insight.

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

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

The description is relatively long and contains domain-specific jargon (e.g., 'bundle-with-shared-envelope pattern') that may not be helpful for an AI agent. While it is front-loaded with the critical paid-tier warning, the overall structure could be more concise by removing extraneous details. The length is justified for the complexity, but it 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?

The description covers key aspects like input parameters, example call, output modes, and deliverable options. However, it lacks a formal output schema description; the agent must infer return values from the text. Given the tool's complexity (nested params, many options), the description leaves some gaps (e.g., exact structure of 'full_json' output). It is 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 only 25% schema description coverage, the description partially compensates by explaining the high-level parameter categories (orifice, flap valve, weir, penstock, scour protection) and providing example parameter values and an example call. However, it does not detail each parameter's meaning or constraints beyond a few examples, so agents must rely heavily on the schema for full parameter 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 uses a specific verb ('compute') and clearly identifies the resource ('Headwall — Attenuation Outlet BoQ'). It distinguishes from sibling tool 'compute_headwall' by noting it is the paid-tier alternative. The purpose is unambiguous: it computes a bill of quantities for a controlled attenuation outlet headwall with ironmongery and scour protection.

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 it is paid-tier only and directs users to the free-tier alternative 'compute_headwall' for unpaid access. It provides a URL for pricing and mentions authentication requirements. It also gives example parameters and an example call, helping the agent understand when and how 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?

Annotations declare readOnlyHint=true, suggesting read-only behavior, but the description indicates a paid operation that creates deliverables (Excel, DXF, PDF) and returns errors without authentication. This is a clear contradiction, and the description adds context about tier requirements but conflicts with annotations.

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

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

The description is long but front-loads critical tier and availability info. Every sentence adds value, though some parameter details could be streamlined. Generally well-structured.

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

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

Given the tool's complexity (many parameters, nested objects, output schema exists), the description covers tier constraints, standards, example usage, and catalogue-driven sizing. It is fairly complete for the 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?

Schema description coverage is only 25%, but the description adds significant meaning: explains size enum values, bedding types, example parameter ranges and defaults, and references a catalogue. This compensates for low 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 states the tool computes a BoQ for precast concrete outfall headwalls, distinguishes from the free-tier sibling 'compute_headwall', and specifies standards and sizing ranges. This is a specific verb+resource with sibling differentiation.

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

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

Explicitly states 'Paid tier only', provides alternative 'compute_headwall' for free tier, and describes when to use UK precast headwall. Includes example calls and omitted parameter defaults.

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

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

Annotations only provide readOnlyHint=true. The description adds significant behavioral context: authentication requirement, specific error message (TIER_INSUFFICIENT), discrimination of channel types, defaults for omitted parameters, and generation of deliverables with download URLs. It does not contradict annotations and provides value beyond the minimal annotations.

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

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

The description is verbose, containing multiple paragraphs with technical details (e.g., 'second highway L1 family outside Section Q after S39 lighting → V41') that are not essential for agent understanding. It could be more concise and better structured, though it front-loads important usage constraints.

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 (many parameters, nested object, output schema exists), the description covers authentication, alternative, standards, output formats, defaults, and an example call. It omits explicit listing of required parameters beyond the example, but the example suffices. Output schema information is not needed as it exists separately.

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 already provides detailed descriptions for most sub-parameters (depth_class, channel_type, outfall_type, silt_box_type). The description adds context about the 5x4 grid and example parameters but does not significantly enhance understanding of individual parameters beyond the schema. Top-level parameters like standard and output_mode lack descriptions, but the description mentions deliverables loosely.

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

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

The description clearly states the tool computes a Bill of Quantities for highway drainage channel installation per UK standards, specifying verb 'compute' and resource 'Highway Drainage Channel BoQ'. It distinguishes from the sibling tool 'compute_end_area_earthworks' which is mentioned as a free-tier alternative.

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

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

The description explicitly states when to use this tool vs the alternative: 'Paid tier only...use the free-tier alternative compute_end_area_earthworks'. It also implies use for highway drainage channel calculations, not for other drainage structures.

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

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

Annotations already indicate readOnlyHint=true, so the description rightfully focuses on other behaviors: tier restriction (paid) and authentication requirements, sensible engineering defaults for omitted parameters, and optional file generation (xlsx, dxf, pdf). No contradiction with annotations.

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

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

The description is somewhat lengthy but well-structured: tier/authentication first, then assembly composition, standards, examples, and optional deliverables. Every sentence serves a purpose (e.g., defaults, profiles, call example). Slightly more verbose than necessary but packed with valuable detail.

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

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

Given the tool's complexity (many parameters, nested object, multiple standards, tier restrictions, file generation), the description covers all essential aspects: authentication, assembly details, supported profiles/channels, example call with ranges, and deliverables. The output schema exists (not shown here) so return values need not be described. Very 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 low (25%), but the description compensates with detailed examples (kerb_length=25 m, range 1–1000; bed_thickness_mm=150 mm, range 75–300; bed_extra_each_side_mm=100 mm, range 0–300) and explains kerb profile types (HB2/HB1/SP/BN/EF/ER) and channel options. It adds meaning beyond the schema, especially for the nested params object.

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 it computes a precast concrete kerb run BoQ, listing assembly components (excavation, sub-base, concrete bed, kerb units, etc.) and supported standards (CESMM4, NRM2, MMHW, SMM7). It explicitly distinguishes from sibling tools by mentioning a free-tier alternative (compute_cantilever_wall) and specifying the linear kerb run 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?

Explicitly states 'Paid tier only' and directs to free alternative for non-authenticated users. It describes the typical use case (linear precast concrete kerb on concrete bed and haunch over Type 1 sub-base). While it doesn't list explicit exclusions, the purpose is so specific that usage 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?

Discloses authentication requirement and tier restriction. Describes the large 24-cell banded grid and the return of download URLs for deliverables. Annotations already declare readOnlyHint=true, so no contradiction; the description adds useful context about the computation's scope.

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 comprehensive but quite verbose, with a lot of internal detail (e.g., banded grid, handler code). The first sentence captures purpose, but overall could be more concise to reduce processing overhead for an AI 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 complexity of parameters, nested objects, and multiple standards, the description covers purpose, usage, parameter defaults, examples, and output formats. An output schema exists, so return values are handled externally.

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 25%, but the description elaborates on key enums (column_type, foundation_type, etc.) and explains defaults. Adds meaning beyond the schema for the major parameters, though not exhaustive for all 11 sub-parameters.

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

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

The description clearly states the tool computes a BoQ for highway/street lighting column installation per BS EN 40 + BS 5489-1:2020 + TR 22. It names the output (Excel, DXF, PDF) and distinguishes from the free-tier sibling compute_end_area_earthworks.

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

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

Explicitly states 'Paid tier only' and provides the free-tier alternative. Includes example parameter values and a full example call, plus explains default behavior and optional deliverables.

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

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

Annotations indicate readOnlyHint=true, and the description confirms a read operation (computes BoQ, renders standards). It adds behavioral details: tier restrictions, deliverables (xlsx, dxf, pdf), watermarking, and composite assembly components. No contradictions. However, it does not mention rate limits or authentication beyond 'anonymous callers welcome'.

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 well-structured, front-loading key information about tiers, standard restrictions, and assembly components. While it is somewhat long, every sentence adds value. It could be slightly more concise, but it is not verbose.

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

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

Given the tool's complexity (30+ parameters, nested object, output schema exists), the description covers essential aspects: input examples, defaults, deliverables, and output modes. It does not explain the return structure, but the output schema fills that gap. The description is sufficient for an agent to make a correct call.

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

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

Schema description coverage is 0%, so the description must compensate. It provides example parameters with typical values and ranges (e.g., internal_diameter=1.5, wall_thickness=0.15, invert_depth=3.5) and mentions that omitted parameters use sensible defaults. However, it does not describe all parameters, leaving many undocumented. This partial compensation earns a 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 computes a Bill of Quantities (BoQ) for precast concrete circular manholes. It specifies the composite assembly and distinguishes itself from similar tools by indicating the standard coverage (MMHW free, others paid). The verb 'compute' and resource 'manhole' are specific.

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

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

The description provides explicit context on when to use: free tier for MMHW, paid tier for others. It welcomes anonymous callers and mentions sensible defaults. However, it does not explicitly compare with sibling tools like compute_manhole_precast or provide when-not-to-use 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?

Discloses authentication requirements (paid tier), default parameter behavior, and one-shot delivery of downloadable files (Excel, DXF, PDF). No contradiction with readOnlyHint annotation, as the tool is a stateless computation generating results, not mutating external state.

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

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

The description is verbose, covering paid tier warning, construction details, standards, example parameters, and deliverables in a single block. While informative, it could be more concise (e.g., separating authentication guidance from parameter 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's complexity (multiple standards, nested params, deliverables), the description provides adequate context: purpose, usage caveats, example call, and output options. With an output schema present (as per context signals), it does not need to detail return values.

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 only 25% schema coverage, the description compensates by explaining catalogue-driven sizing (PMC_1200–PMC_2400), giving example parameters with ranges, and noting that omitted parameters use sensible defaults. However, not all 20+ parameters are individually clarified, leaving some ambiguity.

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 explicitly defines the tool as computing a BoQ for a precast monolithic manhole, details the construction type (BS 5911-3), and contrasts with sibling 'compute_manhole' for free-tier alternative. The verb 'compute' and resource 'manhole precast' are specific and differentiated.

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

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

Clearly states 'Paid tier only' and directs users to the free alternative 'compute_manhole' if they lack an authenticated CivilQuants account. Provides example parameters and standards (e.g., MMHW), giving agents clear context for 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?

Annotations provide readOnlyHint, and the description adds important behavioral context: each section consumes one daily slot, and non-linear items return INVALID_INPUT. No contradiction with annotations.

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

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

The description is a single paragraph but well-structured: starts with core function, lists use cases, constraints, free tier info, and an example. Every sentence adds value, no fluff.

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

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

Given the complexity (8 parameters, nested sections) and the presence of an output schema, the description covers the essential concept, constraints, and provides an example. Some optional parameters are not detailed, but core usage is fully explained.

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

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

With 0% schema coverage, the description compensates by explaining critical parameters: assembly_slug must be a sectioned assembly, sections array with labels and run lengths, shared_params applied to all. An example illustrates usage. However, some parameters (deliverables, aggregate_boq, include_backup, include_section_boq) are not explicitly explained.

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 ('compute'), the resource ('sectioned/linear assembly across multiple sections'), and the output ('combined Bill of Quantities plus per-section results'). It distinguishes from siblings by specifying that it is for multi-section assemblies like walls and drains, and notes that non-linear items return INVALID_INPUT.

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

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

It explicitly says to use for walls, kerb runs, drains, or barriers that change length, and implies not for single-section assemblies. It also mentions free tier limitation. However, no explicit alternatives or when-not-to-use are stated, though the context of single-section compute tools is clear from sibling names.

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 transparently discloses authentication requirements and returns TIER_INSUFFICIENT error, aligning with readOnlyHint annotation (no state change). It mentions behavior for deliverables parameter (one-shot download URLs). No contradictions with annotations.

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

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

The description is well-structured: starts with critical tier info, then purpose, example parameters, and deliverables. It is slightly lengthy but every sentence adds value. Front-loads 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 high number of parameters and options (deliverables, output modes), the description provides essential guidance but lacks explanation of less common parameters and output schema. However, the output schema exists separately. Overall adequate 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 has 0% description coverage, but the description compensates by giving example parameters with ranges and explaining the deliverables parameter. However, many parameters (e.g., top_mat, cover_mm, working_space) are not explained beyond schema defaults. The description adds value but does not cover all parameters.

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

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

The description clearly states it computes a BoQ for a single isolated reinforced concrete pad foundation with optional pedestal, and mentions integration with reinforcement scheduling. The title 'Compute Concrete Pad Foundation BoQ' matches. It distinguishes from sibling tool compute_cantilever_wall as a free-tier alternative.

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

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

The description explicitly says 'Paid tier only' and mentions the error for unauthenticated users, providing a free-tier alternative. It includes example parameters and a call example, and explains the deliverables parameter. It gives clear context but does not explicitly list when to not use this 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?

Annotations only provide readOnlyHint: true. The description adds crucial behavioral information: authentication constraints (paid tier), error code for insufficient tier, defaulting of parameters, and the ability to receive one-shot download URLs for deliverables. No contradiction with annotations.

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

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

The description is overly verbose with extraneous details like 'LAUNCH-COMPLETING 45TH ASSEMBLY', 'SEVENTH 1D-banded handler', and 'second principled rejection of forced 2D banding'. While packed with information, it lacks structure and front-loading for an agent. Could be streamlined to focus on invocation-critical info.

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 complexity (4 parameters, enums, nested objects) and the existence of an output schema, the description covers parameter semantics, usage constraints, and deliverables. However, it misses explicit guidance on when to use this tool vs the many sibling tools beyond the one free-tier alternative, and it includes extraneous project status. Still, 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 only 25%, but the description provides extensive meaning for all parameters, including detailed explanations of enum values (four parapet_type classifications, nine containment_level values), constraints (height 900-1800 mm, length 1-2000 m), and the role of transition_type and post_count. It compensates fully for low 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 states it computes BoQ for bridge/structural deck parapet installation per UK standards (BS 6779-1, BS EN 1317-2, SHW Cl. 408). It distinguishes from siblings by mentioning the free-tier alternative compute_end_area_earthworks and by being a specific parapet handler. No sibling tool duplicates this purpose.

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

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

Explicitly states 'Paid tier only' and that unauthenticated calls return TIER_INSUFFICIENT, with a sign-up URL and a free-tier alternative (compute_end_area_earthworks). It also gives an example call and notes omitted parameters use sensible defaults. Clear when-to-use and when-not-to.

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

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

Discloses paid tier, error response (TIER_INSUFFICIENT), deliverables behavior (watermarked for free tier), and UK trade-boundary platform principle. Does not reveal error handling for invalid inputs, but annotations (readOnlyHint=true) are consistent. Minor gap: no mention of performance 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 structured with clear sentences covering tier, standards, parameters, and example. It is slightly lengthy but each sentence adds value. Could be more concise, but effectively communicates necessary info without fluff.

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

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

Given the tool has an output schema (not shown, but context says true), the description does not need to detail return values. It covers purpose, inputs, tier, and deliverables adequately. Missing: explanation of output_mode and standard options, but that is mitigated by output schema and sibling 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?

The description adds meaning beyond the schema by explaining defaults (e.g., length=12m, width=5m, reservoir_thickness_mm=350) and providing an example call. It clarifies the deliverables parameter and the 'params' object structure. Schema descriptions exist for many inner properties, so description complements well.

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 tool computes permeable pavement BoQ per CIRIA C753, covering three UK surface types and infiltration regimes. It distinguishes itself from siblings like compute_flexible_pavement and compute_rigid_pavement by its specific domain, and even names a free-tier alternative (compute_end_area_earthworks).

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

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

Explicitly states paid tier requirement, provides a free alternative, and includes example parameters and a full example call. It also mentions omitted parameters use sensible defaults, guiding usage. No ambiguity about when to use this tool.

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

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

The description describes generating deliverables (Excel, DXF, PDF) and opening a drainage_treatment leaf, implying write-side effects or document creation, which contradicts the readOnlyHint annotation indicating a read-only 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 lengthy but front-loaded with critical access info (paid tier) and structured with technical details, examples, and output options. Some redundancy with schema defaults, but overall efficient.

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

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

Given the tool's complexity (multiple parameters, standards, output modes, deliverables), the description covers all essential aspects: standards, catalogue selection, engineering assumptions, output options, and example usage. Output schema exists, so return values need not be detailed.

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

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

With only 25% schema description coverage, the description compensates well by explaining the three catalogue axes (size, class, type), providing example parameters and an example call, and clarifying engineering defaults.

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

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

The description clearly states the tool computes a BoQ for a prefabricated petrol/oil interceptor, specifying standards (BS EN 858, SHW) and differentiating from sibling compute_manhole as a free-tier alternative.

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

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

Explicitly states paid-tier requirement, returns TIER_INSUFFICIENT error without authentication, and recommends free-tier alternative compute_manhole. Provides clear context on when to use this tool.

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

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

Annotations declare readOnlyHint=true. Description adds behavioral context: paid tier, authentication requirement (TIER_INSUFFICIENT), and one-shot download URLs for deliverables. Does not contradict annotations. Lacks explicit mention of side effects beyond computation.

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 comprehensive but somewhat lengthy. Front-loaded with critical info (paid tier, alternative). Well-structured with logical flow: constraints, strategy, standards, example, deliverables. Could trim redundant phrases but overall efficient for the complexity.

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

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

Covers most necessary aspects: purpose, limitations, standards, defaults, example, outputs. Missing detailed return value description but output schema likely provides that. Adequate for a complex tool with many parameters and deliverables.

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% (many parameters lack descriptions). Description compensates by explaining the strategy pattern (BeddingContext × BeddingClass), providing example parameter ranges and values, and detailing deliverables. Adds meaning beyond schema enums with usage context.

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 the tool computes pipe bedding and surround BoQ. Differentiates from sibling 'compute_manhole' by specifying it's the paid-tier alternative. Includes specific verb ('compute') and resource ('pipe bedding and surround BoQ').

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

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

Explicitly states paid-tier requirement, mentions the free-tier alternative ('compute_manhole'), and describes when to use (linear pipe trench). Provides example parameters and call syntax. Clearly guides the agent on prerequisites and alternatives.

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

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

Annotations declare readOnlyHint: true; description adds that it returns deliverables (Excel, DXF, PDF) and can raise TIER_INSUFFICIENT error. Does not contradict annotations and adds useful behavioral context beyond read-only nature.

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

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

Front-loaded with critical info (tier restriction, purpose), but the description is verbose. Every sentence adds value, yet could be more streamlined for 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 complexity (multiple standards, four parameters, nested input, various output modes/deliverables), the description is comprehensive. It explains standards, variants, example calls, error conditions, and output formats. Output schema exists but description provides additional context.

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

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

Schema description coverage is 25% (only test_method has a detailed description). The tool description compensates by explaining the discriminator pattern, eight variant presets, example params with ranges, and default usage info, adding significant 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 tool's purpose: linear measurement of testing on new drainage pipework (CCTV, air/water pressure, mandrel pull) with specific CESMM4/NRM2/MMHW/SMM7 references. It distinguishes itself as 'third member of the drainage_ancillaries L2 leaf' and '21st use of the discriminator pattern via test_method', setting it apart 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?

Explicitly states 'Paid tier only' and directs free-tier users to 'compute_manhole' as an alternative. Provides examples, parameter defaults, and variant presets, making usage conditions 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?

Annotations declare readOnlyHint=true, and the description confirms this is a compute operation. Additionally, it discloses tier requirements, authentication needs, omitted parameter defaults, and the ability to request deliverables like xlsx/dxf/pdf, adding value beyond annotations.

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

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

The description is overly verbose, containing esoteric details like '17th use of the classed-then-legacy attribute discrimination pattern' that are irrelevant for tool selection. While the first sentence is front-loaded, the length detracts from 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 (nested parameters, multiple standards, facing variants, deliverables), the description covers purpose, usage, parameters, defaults, codes, and example calls. The presence of an output schema means return values need not be described, so completeness is high.

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

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

Despite low schema coverage (25%), the description extensively explains the parameter structure, default values, and facing variants. It gives example parameters and sensible defaults, compensating for the missing schema descriptions at the top level.

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 title and description clearly state this tool computes a Bill of Quantities for reinforced soil walls. It distinguishes itself from siblings by specifying the wall type, facing systems, and referencing a free-tier alternative (compute_cantilever_wall). The purpose is specific and unambiguous.

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

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

The description explicitly notes this is paid tier only and directs users to the free alternative compute_cantilever_wall if authentication is lacking. It also provides typical use cases, standards, and example parameters, giving clear when-to-use guidance.

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

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

Annotations declare readOnlyHint=true, consistent with the description's focus on computation (no mutations). Description adds detail about internal routing logic (v12 slab discrimination, v8 fill handlers) and deliverables (xlsx, dxf, pdf), which goes beyond the annotation. 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 lengthy but well-structured: starts with tier info, then components, example, and deliverables. Each sentence adds value. Could be slightly more concise, but for a complex tool with many parameters, the detail is warranted.

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 (many parameters, nested object, output schema exists), the description covers the essential aspects: pavement types, reinforcement standards, deliverables, and tier restrictions. The output schema handles return value details. Minor gaps exist (e.g., interaction of certain parameters), but overall sufficient.

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 25% (low), but the description compensates by explaining key parameters with example values and ranges (e.g., length=50m, width=7m, sub_base_thickness_mm=150mm). It also discusses defaults and sensible engineering defaults for omitted parameters. Not every parameter is covered in detail, but the overall semantics are 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 it computes rigid pavement build-up BoQ, lists components (capping, sub-base, membrane, slab, reinforcement) and standards (CESMM4, NRM2, MMHW, SMM7). It differentiates from siblings like compute_flexible_pavement and compute_permeable_pavement by specifying 'rigid (concrete)' and mentioning a free-tier alternative compute_end_area_earthworks.

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

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

Explicitly states 'Paid tier only' and describes authentication requirement. Provides example parameters and defaults, and mentions free-tier alternative. Does not explicitly contrast with other pavement tools, but the specificity of 'rigid pavement' and mention of DMRB CD 226 guidelines provides sufficient 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?

Discloses authentication requirements, output formats (xlsx, dxf, pdf with download URLs), internal item routing, and material treatment. Adds significant context beyond the annotations (readOnlyHint: true) without contradiction.

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

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

Overly verbose with internal taxonomy details (e.g., 'THIRD member of the highway L1 leaf') and repetitive parameter descriptions. The essential guidance is buried in a dense paragraph. Not 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?

Covers all aspects: authentication, standards, alternatives, parameter semantics, output modes, deliverable formats, and example. Despite complexity (4 parameters, nested object, output schema), the description leaves no 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?

Adds extensive meaning beyond the schema: geometry interpretation, discrimination rules, defaults anchored to a real scenario, and explanations for each parameter's role. Low schema coverage (25%) is compensated by rich description.

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

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

The description clearly states it computes a Road Marking BoQ with specific UK standards and discriminators. It distinguishes from siblings by naming the free-tier alternative compute_end_area_earthworks and providing internal taxonomy 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?

Explicitly notes paid tier and free alternative, provides example parameters and call, explains when to set parameters to zero, and offers default behavior. No ambiguity about prerequisites or context.

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

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

The description discloses authentication behavior (returns TIER_INSUFFICIENT if not authenticated), output modes (summary, material_schedule, boq, etc.), and optional deliverables (xlsx, dxf, pdf). These add context beyond the readOnlyHint annotation, which is consistent with a compute operation. No contradictions.

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

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

The description is somewhat long but well-structured, starting with the paid-tier warning and moving through purpose, example, and output options. It is front-loaded with critical information but could be more concise by reducing 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 (4 top-level parameters, nested objects, multiple standards, deliverables), the description covers authentication, purpose, standards, parameters, and output formats. The presence of an output schema reduces the need to describe return values.

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 low schema description coverage (25%), the description compensates by providing example parameter values, ranges, and an example call. It explains important parameters like bedding_thickness_m and service_type. However, many parameters still rely on the schema for their 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 clearly states 'Single-service utility run per NJUG Volume 1' and enumerates the specific utilities (water main, gas main, etc.). It distinguishes itself from sibling tools like compute_combined_services_trench by noting it wraps the combined engine with a single-band envelope.

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 'Paid tier only' and mentions a free alternative (compute_manhole). It gives context about when to use this tool (single-service runs) and implies alternatives for multi-service or free-tier use. However, it does not explicitly contrast with similar siblings like compute_combined_services_trench.

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

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

Annotations already declare readOnlyHint=true, so the description goes beyond by detailing the paid tier requirement, error response (TIER_INSUFFICIENT), the computational engine (rational-method sizing, factors of safety, half-emptying time check), and the wrapping of attenuation_tank. This adds valuable context without contradicting the annotations, though it does not cover rate limits or auth steps beyond the initial check.

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

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

The description is relatively long but well-organized, front-loading the critical paid-tier warning and then systematically covering the tool's standard, sizing engine, output items, and example usage. It avoids redundancy and each sentence contributes information, though it could be slightly more concise without losing 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 (many parameters, nested input schema, and an output schema that is present but not shown here), the description covers the key usage context: the two ways to specify the design storm, soil characterization factors, geometry considerations, and deliverables (xlsx, dxf, pdf). It does not describe the output structure in detail, but the existence of an output schema reduces the burden. The description is mostly complete for an agent to understand how to invoke the tool correctly.

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

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

With only 25% schema description coverage, the tool description provides some parameter context through example values and a brief explanation of key parameters (catchment_area_m2, rainfall_depth_mm, measured_infiltration_rate_m_per_s). However, it does not elaborate on every parameter, leaving many details to the schema's own description for the 'params' object. This partially compensates for the low coverage but not fully, resulting in a score 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?

Description clearly states the tool computes infiltration soakaways per CIRIA C753. It specifies the storage envelope types (granular-fill or modular-crate) and mentions the sizing engine. It distinguishes itself from the sibling 'compute_attenuation_tank' by noting it as a free-tier alternative, thus clarifying the tool's specific 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 provides explicit guidance on when to use this tool (for infiltration soakaways under CIRIA C753) and when not to, by naming the free-tier alternative 'compute_attenuation_tank'. It also includes constraints like the prohibition of VERY_HIGH hot-spot catchments without pre-treatment, and example parameters and calls that help the agent understand typical 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?

Annotations indicate readOnlyHint=true, so the tool is read-only. The description adds behavioral context: paid-tier restriction, computation and return of BoQ files, output formats (xlsx, dxf, pdf), and default parameter handling. It also details the face system enum extensively. No contradictions with annotations. However, some internal jargon ('classed-then-legacy pattern') may be unnecessary, but overall transparency is high.

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 lengthy (~600 words) and includes many technical details and numbering (e.g., '23rd use of pattern'). While it front-loads the tier restriction and alternative, the later parts become dense with specific standards and code references. It could be more concise and better structured (e.g., separate sections). It earns its sentences but 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 the tool's complexity (nested parameters, multiple enums, output schema exists), the description covers the core purpose, key parameters, face system options, and output deliverables. It provides example calls and explains default behaviors. Missing detailed descriptions for some sub-parameters (e.g., steel_grade, geogrid_grade) and does not explain the output schema, but the latter is not required. Overall, it is fairly complete for an agent to 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 description coverage is low (25%), but the description compensates by providing detailed meanings for key parameters like face_system, nail_permanence, and the geometry interpretation of the params object. Example param values are given. However, many sub-parameters (e.g., steel_grade, geogrid_grade) lack description. The description adds value beyond the schema but is incomplete for all 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 title and description clearly state it computes the Bill of Quantities for soil-nailed slopes, with specific verb 'compute' and resource 'soil-nailed slope BoQ'. It explicitly distinguishes from the sibling tool compute_cantilever_wall, noting it as a free-tier alternative. The description also details the four face systems and standards, making the tool's specific purpose 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?

The description clearly states the tool is paid tier only, requiring an authenticated CivilQuants account, and returns TIER_INSUFFICIENT otherwise. It directs users to the free-tier alternative compute_cantilever_wall. This provides explicit when-to-use and when-not-to-use guidance.

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

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

The annotation readOnlyHint=true contradicts the description which claims computation (creates BoQ, requires auth, returns error if not). The description itself is clear about behavior (paid tier, error handling), but the contradiction with annotations reduces trust. Per guidelines, a score of 1 is given due to contradiction.

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

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

The description is front-loaded with critical access information and provides context, examples, and deliverables. It is relatively long but each sentence adds value. Some technical phrasing (e.g., 'cross-cutting standards-handler discrimination') may be unnecessary for most agents.

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 (many parameters, nested object, output schema exists), the description covers key aspects: paid tier, alternative, example call, default behavior, and deliverable options. It does not detail return values, but the output schema is available. It is sufficiently complete for a competent 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 low (25%), but the description provides example parameters with ranges (e.g., length 1–100 m) and defaults tuned to UK domestic. However, only three of many nested parameters are exemplified, so compensation is partial. The description adds value but not comprehensive 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 uses specific verb 'compute' and resource 'strip foundation BoQ'. It distinguishes from sibling 'compute_cantilever_wall' as a free-tier alternative and mentions it completes the P1 launch set with 'pad_foundation'. The purpose is clear and differentiated.

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

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

The description explicitly states the paid-tier requirement, provides a free alternative (compute_cantilever_wall), and gives an example call with parameter settings. However, it does not explicitly state when not to use this tool versus other similar tools, though the mention of 'strip foundation' implies scope.

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

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

Discloses tier restrictions (TIER_INSUFFICIENT error), watermarking for free tier, and that DXF/PDF require paid tier. readOnlyHint annotation is consistent with compute 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?

Well-structured and information-dense, with tier info first, then purpose, parameter details, example. Could be slightly more concise but every sentence adds value.

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

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

Given tool complexity (many parameters, nested objects, output schema exists), description covers usage, tier restrictions, defaults, deliverables, and example. Output schema handles return values, so no need to describe them.

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 only 0% of parameters (no descriptions in schema for most properties). Description compensates by explaining parameter ranges (e.g., bed_width 0.2–3), slopes, lining strategies, check dams, and defaults. Example call adds clarity.

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 computes a SuDS swale BoQ per CIRIA C753, covering three lining types. It distinguishes from sibling tool compute_attenuation_tank as a free alternative, and the purpose is specific and unambiguous.

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

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

Explicitly states 'Paid tier only' and provides the free alternative compute_attenuation_tank. Includes example params and call, explains omitted parameters use defaults, and describes deliverables. Guidance is clear and comprehensive.

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

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

Discloses authentication requirements, tier insuffiency error, and deliverable URLs. Annotations already set readOnlyHint=true, so the description adds value by detailing the paid-tier restriction and error behavior without contradiction.

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

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

The description is extremely verbose, listing numerous codes, standards, and leaf relationships. While informative, it lacks conciseness and could be better structured with bullet points or sections.

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 authentication, standards, sign types, presets, codes, example calls, and deliverables. With a complex input schema and output schema, the description provides comprehensive context, though it could be more streamlined.

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 25%, but the schema itself has extensive descriptions for each parameter. The tool description adds some additional context (e.g., leaf membership, codes) but not significant parameter-level details beyond what the schema 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?

The description clearly states the tool computes a traffic sign BoQ, distinguishing it from the free-tier alternative compute_end_area_earthworks. It also provides context on sign classifications and standards, making the purpose unmistakable.

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

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

Explicitly states 'Paid tier only' and directs users to the free alternative. Describes when to use different sign types and presets, and mentions deliverables options. Provides clear guidance for correct 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?

Discloses authentication requirement, error code, default behavior for parameters, and one-shot download URLs for deliverables. No contradiction with annotations.

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

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

The description is comprehensive but not excessively verbose; front-loaded with critical info (paid tier, alternatives). Some redundancy in enumerating standards 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?

Covers authentication, alternatives, catalogue details, standard routing, example params, and deliverables. Output schema exists for return values, so no gap.

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

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

While schema coverage is low (25%), the description adds meaning for key parameters like chamber_type and supply_route defaults, and provides example values for bedding and surround. Could mention standard and output_mode explicitly.

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

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

The description clearly states the tool computes a Bill of Quantities for utility access chambers, specifies the ten chamber types, and distinguishes from the free-tier alternative compute_manhole.

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

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

Explicitly states paid tier requirement, provides alternative for free tier, and includes example call with standard parameters.

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

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

Discloses paid-tier requirement, delegation to pad_foundation, and catalogue-driven defaults. Does not contradict readOnlyHint annotation. Adds value beyond annotations by explaining the composite structure and engineering defaults.

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 verbose and contains multiple technical sentences. While front-loaded with critical info, it could be more concise without losing essential 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?

For a complex tool with many parameters and a nested input schema, the description covers usage, defaults, output options, and sibling alternatives. Output schema exists so return values are not required. Adequately 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?

Describes key parameters (quantity, blinding_thickness_m, working_space_m) with example ranges and explains kiosk_type enum values. Adds meaning beyond the schema, though not all parameters are covered.

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 computes a Bill of Quantities for utility kiosk bases, listing the specific kiosk types it covers. It distinguishes itself from siblings by mentioning the free-tier alternative compute_manhole.

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

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

Explicitly states paid-tier-only and provides a free alternative. Offers example parameters and call, explains defaults, and describes how to request deliverables. Gives clear when-to-use and when-not-to-use guidance.

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

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

The description discloses authentication requirements (paid tier), output modes including downloadable deliverables, and the first-time use of a 2D-banded pattern. It adds context beyond the readOnlyHint annotation, which is consistent with a compute-only operation. No contradiction with annotations.

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

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

The description is front-loaded with critical info (paid tier, authentication, alternative) and is well-organized, but it is verbose, containing extensive details that could be shortened. Still, every sentence provides value, so it earns a 4 rather than a 5.

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

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

The description covers all aspects: purpose, usage constraints, system types, variant presets, work categories, standard codes, example call, deliverables, and output behavior. It is fully complete for a complex tool with many parameters and enums.

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

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

Despite low schema description coverage (25%), the tool description thoroughly explains each system type, the meaning of key parameters like post_spacing_m and terminals_per_run, and provides example parameter values and an example call. It compensates fully for missing schema descriptions.

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

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

The description clearly states the tool computes Vehicle Restraint System (VRS) BoQ per SHW and BS EN 1317, with specific verb 'compute' and resource 'VRS BoQ'. It distinguishes from siblings by mentioning it is the first member of a new highway category and explicitly names the free-tier alternative compute_end_area_earthworks.

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 'Paid tier only' and provides the exact error message for unauthenticated users, along with a link to sign up and an alternative free tool. It also mentions that omitted parameters use sensible engineering defaults, giving clear when-to-use and when-not-to-use guidance.

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

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

Annotations already declare readOnlyHint=true. Description adds further behavioral context: explains that a chat connector can read but not execute, and provides details on component sizes and self-unpacking nature.

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

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

Two main sentences plus a note. Information is front-loaded with purpose, then components, then usage constraint. Efficient but could slightly trim the list of skill types in the first sentence.

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 only one optional parameter and presence of output schema, the description covers the tool comprehensively. Mentions return values (chunking package, discipline, render helpers) and size details. No missing critical 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 coverage is 100%, but the description adds value by explaining the component enum values with size estimates and clarifying that omitting gets the whole kit.

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 obtains the CivilQuants customer-side document pipeline, used by document-heavy skills. It distinguishes itself from computational sibling tools by explicitly listing its purpose and components.

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 explicit usage guidance including that running the pipeline requires a code-execution client, and a chat connector can only read but not execute. Does not explicitly name alternatives, but given sibling tools are compute-focused, the 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?

Adds behavioral info beyond readOnlyHint annotation: error envelopes with candidate IDs when names conflict, tier restriction for anonymous callers.

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

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

Three concise sentences front-loading core purpose, then alternatives and constraints. No wasted words.

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

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

Covers parameter semantics, failure modes, tier requirements, and alternative tools comprehensively for a simple fetch tool.

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

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

With 0% schema description coverage, the description fully compensates by explaining the single parameter accepts both ID and exact display name.

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 the tool fetches a project by project_id, with explicit alternative usage (display name). Distinguishes from siblings like list_projects and recompute_project.

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

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

Provides explicit guidance on when to use project_id vs display name, handles naming conflicts by referring to list_projects, and mentions paid tier restriction.

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

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

Beyond the readOnlyHint annotation, the description details that no inference is run by CivilQuants, the returned body is a system instruction, and different response bodies (TIER_INSUFFICIENT, INVALID_TOKEN) occur based on caller status. It also explains prerequisites for document-heavy skills, adding significant behavioral context.

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

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

The description is concise yet comprehensive, front-loading critical info ('Paid tier only'). Each sentence adds necessary context, including example usage, and there is no verbosity. Ideal structure for quick agent comprehension.

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 and existing output schema, the description covers all essential aspects: what is returned, different response scenarios, prerequisites, related tools (list_skills, get_document_pipeline), and usage constraints. No gaps remain.

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 already describes the 'skill' parameter as 'Skill slug from list_skills' with 100% coverage. The description adds an example and confirms the slug source, but does not substantially improve meaning beyond the schema. 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?

The description clearly states the tool fetches a senior-QS skill methodology by slug and returns system instructions for the agent to apply. It distinguishes from siblings like list_skills (listing) and get_document_pipeline (document pack) by specifying its unique role.

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 specifies 'Paid tier only', advises to see list_skills for the slug, and explains different response bodies for free/anonymous/rejected callers. It also mentions when code-execution is needed versus chat usage, providing clear context for when to invoke this tool.

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