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

Annotations already declare readOnly/idempotent/non-destructive/closed-world, but the description adds substantial behavior the agent cannot infer: pure arithmetic with no I/O, rounding to 2 decimals, foreign-method parameters being accepted and silently ignored, and error-on-unknown-method or missing-required-param. That is exactly the extra context the annotation bar asks for.

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

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

The definition is front-loaded with purpose, then the alternative routing, then per-method requirements, then behavioral rules, then error semantics – a logical order. It is dense but each sentence carries distinct information; only mild tightening is possible in the per-method parameter list.

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 method-dispatching calculator with an output schema present, the description covers everything an agent needs: which method, what each method requires, unit conventions, additional-parameter handling, and failure modes. Return-value explanation is correctly left to the output schema.

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

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

Schema coverage is 100%, so the baseline is 3, but the description goes further by stating which parameters each method requires (cup_transfer_price needs controlled_price + uncontrolled_prices; patent_infringement_damages needs lost_profits_or_royalty + infringement_period + discount_rate + prejudgment_interest_rate), the decimal convention, and that only method is universally required. It stops short of explaining the formula mechanics behind each price/rate 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 states two specific computations – the CUP arm's-length range and patent infringement damages with pre-judgment interest – with the resource (transfer pricing / litigation) named explicitly. It also names the sibling tools it is not (valuation_royalty_analysis, valuation_ip, valuation_income_methods), so an agent can disambiguate without opening any schema.

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 gives explicit when-to-use conditions for both methods ('OECD transfer-pricing pricing of intercompany intangibles', 'patent infringement damages awards') and routes the agent away to specific alternatives for royalty-rate benchmarking and substantive asset valuation. Both the positive and the exclusion cases are covered.

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 cover the safety profile (readOnly, idempotent, no open world), and the description adds substantial context beyond them: pure arithmetic with no I/O or external calls, 2-decimal rounding, and explicit error behavior for unknown methods or missing method-required parameters. It also states that parameters belonging to other methods are accepted and ignored, which is genuinely useful non-obvious behavior.

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

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

Front-loads scope and routing before the per-method mechanics, and every sentence carries operational content (alternatives, method requirements, decimal convention, error handling). It is dense and slightly long, but no sentence is filler.

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?

An output schema exists, so return values need not be explained. For a 4-parameter, method-branching arithmetic tool with full annotation coverage, the description supplies everything an agent needs: method selection, required vs. optional parameters per method, units/format, and failure modes.

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

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

Schema coverage is 100%, so the per-parameter definitions are already documented and the baseline is 3. The description goes beyond it by explaining cross-parameter semantics: which parameters each method requires, that only method is mandatory, that other-method parameters are ignored, that obsolescence_factors are summed and applied to the cost base, and that rates are decimals.

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

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

States a specific method family (cost approach) and names both sub-formulas — depreciated reproduction cost from a cost breakdown and depreciated replacement cost with equivalent utility — along with the obsolescence reduction. It clearly distinguishes itself from the income and market siblings by naming them.

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?

Gives explicit when-to-use conditions ('when no income or market evidence exists, or to corroborate income and market indications for internally developed intangibles') and routes to named alternatives (valuation_income_methods, valuation_market_approach). Nothing is left to inference.

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

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

Annotations already declare this as a read-only, idempotent, closed-world operation, and the description adds genuinely new behavioral facts: pure arithmetic with no I/O or external calls, results rounded to 2 decimals, defaults applied where defined, and that parameters belonging to other methods are accepted and silently ignored. It also discloses the failure mode (unknown method or missing method-required parameter returns an error rather than a value), which is exactly the kind of contract detail an agent needs.

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

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

It is front-loaded correctly — asset scope and sibling routing come first, method-to-parameter mapping follows, and global caveats (decimal convention, arithmetic-only behavior, error semantics) close it out. The middle section is a dense, comma-spliced run-on that could be bulleted for faster scanning, but essentially every clause carries information an agent needs for a 14-parameter tool.

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

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

With an output schema present, return values need not be explained, and the description covers everything else: enum semantics for method, per-method required inputs, unit conventions, rounding, default handling, ignored parameters, and error behavior. Nothing needed to invoke this tool correctly is missing.

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

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

Schema coverage is 100%, so the baseline would be 3, but the description goes well beyond it by mapping each method to its required parameter set and clarifying cross-parameter rules that no individual schema description states: which parameters are method-dependent, that only 'method' is required, that unspecified parameters fall back to defaults, and that retention_rate/enforcement_probability are unit fractions in [0,1] and projection_period sets the number of discounted periods.

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

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

The description names the specific asset class (customer-related intangibles) and enumerates the three concrete formulas it computes: customer relationships with attrition, distribution networks by channel profitability, and non-compete agreements. It also explicitly routes the agent away from siblings by naming valuation_human_capital and valuation_technology, so the tool is distinguishable without opening any schema.

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 states when to use this tool ('Use for customer relationships, distribution networks, and non-compete assets') and gives explicit alternatives for the adjacent domains (workforce/key-person -> valuation_human_capital; technology -> valuation_technology). It further tells the agent how to select among the three internal methods via the required 'method' parameter.

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 error semantics not covered by annotations: an unknown method or a missing method-required parameter returns an error instead of a value, extra parameters for other methods are accepted and ignored, and results are rounded to 2 decimals. 'No I/O and no external calls' partially overlaps openWorldHint=false/readOnlyHint=true, but the failure-mode and parameter-tolerance disclosure is genuinely additive.

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 purpose, then usage routing, then per-method parameter requirements — a sensible order with no filler. It does repeat the decimal convention ('All rates and premiums are decimals' appears twice), which is minor but redundant.

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 23-parameter, single-required-parameter tool with an output schema, the description covers everything an agent needs: method selection, per-method inputs, defaults/omission behavior, and error conditions. Return-value format is appropriately left to the output schema.

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

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

Schema description coverage is 100%, so the baseline would be 3, but the description supplies cross-parameter conditional semantics the schema cannot express: the exact required/optional parameter set per method (e.g., build_up needs risk_free_rate + equity_risk_premium with size/industry/specific optional; wacc needs both equity_value and debt_value), plus the note that only method is required and other parameters should be omitted.

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

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

States a specific verb and resource ('Construct discount and capitalization rates') and enumerates the exact methods covered (build-up, CAPM, WACC, tax-amortization benefit, control premium, Finnerty DLOM, currency-adjusted). It also distinguishes itself from the sibling valuation_time_value by naming what that tool handles instead.

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?

Explicit routing guidance: 'Use to derive the rate that feeds every income-based method,' build_up/capm estimate cost of equity, wacc blends debt and equity, and currency_adjusted is prescribed for cross-border rates, with valuation_time_value named for the cash flows being discounted. When-to-use and the alternative are both stated.

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

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

Annotations already mark this as read-only, idempotent, closed-world, but the description adds behavior beyond them: 'Pure arithmetic: no I/O and no external calls, rounded to 2 decimals', 'parameters belonging to other methods are accepted and ignored', and explicit failure behavior ('An unknown method, or a missing method-required parameter, returns an error instead of a value'). This is exactly the extra context annotations cannot convey.

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?

Purpose and scope are front-loaded in the first two sentences, followed by alternative routing and then the per-method parameter rules. It is dense and long, but each sentence carries distinct information; only the per-method detail could be trimmed by relying more on the enum descriptions.

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

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

For a 10-parameter, method-dispatched arithmetic tool with an output schema present, the description covers purpose, alternatives, conditional parameter requirements, units, rounding, and error behavior. Nothing an agent needs to invoke it correctly is missing, and return values are legitimately delegated to the output schema.

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

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

Schema coverage is 100%, so the baseline is 3, but the description adds the cross-parameter dependency matrix schema cannot express: which parameters each method requires, which are optional, and the semantics that 'identified_intangibles values are summed before goodwill is taken as the residual' and 'liabilities_fv reduces net identifiable assets'. It also restates the decimal convention for rates.

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

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

The description names a specific verb+resource ('goodwill as the residual, a full PPA waterfall across identified intangibles, and useful-life estimation') and immediately scopes it to ASC 805 / IFRS 3 business combinations. It also differentiates itself from siblings by naming valuation_impairment for subsequent testing and valuation_ip/technology/customer for individual intangible fair values.

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?

Explicit routing: 'Use for ASC 805 / IFRS 3 business combinations', 'For subsequent goodwill and intangible impairment testing use valuation_impairment', and 'for individual intangible fair values feed valuation_ip, valuation_technology or valuation_customer into the allocation'. Both when-to-use and alternatives are stated, plus the per-method parameter conditions.

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

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

Annotations already cover the safety profile (readOnly, idempotent, non-destructive, closed-world), and the description adds genuinely new behavioral facts: pure arithmetic with no I/O or external calls, 2-decimal rounding, unknown-method and missing-required-parameter both returning errors, and extra method parameters being accepted and ignored.

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 purpose, then routing, then per-method parameter requirements, then semantics — a sensible order. It is dense rather than tautological, though the single long paragraph slightly restates schema-level conventions (rate ranges, factor parity) that 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?

For a 10-parameter, 1-required tool with full schema coverage and an output schema, the description supplies the missing glue: method-to-parameter mapping, defaults-apply behavior, error conditions, and the numeric conventions. Nothing essential to correct invocation is left unstated.

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

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

Schema coverage is 100%, so the baseline is 3, but the description adds real meaning beyond the per-field text by grouping parameters per method (assembled_workforce vs key_person) and clarifying that only method is required while the rest are method-dependent defaults. It restates a few conventions (attrition_rate in [0,1], productivity_factor 1.0 = parity, decimals) that the schema already carries, keeping it from a 5.

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

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

States a specific resource (human capital intangibles) and the two distinct valuation outputs (assembled-workforce replacement cost, key-person value), with the method parameter as the selector. It also names the sibling tools it is not (valuation_customer, valuation_technology), so an agent can route without opening schemas.

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?

Explicit when-to-use ('Use for assembled workforce and key-person intangibles') and explicit alternatives for adjacent asset classes (customer-related → valuation_customer, technology → valuation_technology). It also spells out which method to pick via the parameter lists, leaving little to inference.

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

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

Annotations already cover the safety profile (readOnly, idempotent, non-destructive, closed world), yet the description adds substantial context beyond them: pure arithmetic with no I/O or external calls, 2-decimal rounding, error behavior for unknown methods or missing required params, and that foreign-method parameters are accepted and ignored. The only gap is that it doesn't say what a zero/negative result means (no impairment indicated).

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?

Dense but front-loaded: purpose and standards first, then routing, then per-method parameter requirements, then behavioral notes. Nearly every sentence carries load, though the rate/premium decimal sentence adds no value for a parameter set that contains no rates.

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?

An output schema exists so return values need no explanation, annotations carry the safety profile, and the description covers the remaining agent-facing unknowns: method selection, method-dependent required params, error conditions, and numeric precision. Nothing needed to invoke it correctly is missing.

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

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

Schema coverage is 100%, so names/types/defaults are already documented, but the description adds cross-parameter conditional logic the schema cannot express: goodwill_impairment requires carrying_value + fair_value (optional reporting_unit, standard), intangible_impairment requires carrying_value, with fair_value required for ASC350 and recoverable_amount for IAS36. A minor relevance slip is mentioning rate/premium decimal conventions when no rate parameter exists.

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

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

States a specific resource (impairment testing for goodwill and intangibles) with named standards (ASC 350 / IAS 36), and explicitly distinguishes itself from siblings by routing initial goodwill work to valuation_goodwill_ppa and asset fair values to asset-type tools. An agent can tell exactly what this computes and what it does not.

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?

Gives explicit when-to-use (annual or triggering-event impairment testing) and names the alternative tools with the conditions that select them (valuation_goodwill_ppa for initial goodwill/allocation, asset-type tools for underlying fair values). Boundary handling between siblings is fully specified.

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 establish readOnly/idempotent/closed-world, but the description adds substantive behavior: it is pure arithmetic with no I/O or external calls, results are rounded to 2 decimals, non-selected method parameters are accepted and ignored, and an unknown method or missing required parameter returns an error instead of a value. That error semantics and ignore-behavior detail go well 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?

Front-loaded with purpose, then routing, then per-method inputs, and nearly every sentence carries load. However the asset-specific sibling list is stated twice (once as 'prefer the dedicated...' and again as 'for asset-specific income valuations use...'), which is avoidable repetition in an otherwise dense block.

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?

An output schema exists so return values need no prose, and the description still covers method enumeration, per-method required inputs, alignment constraints, unit conventions, ignored extra parameters, and error behavior. For a 14-parameter, 5-method dispatch tool, the agent has everything needed to call it correctly.

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

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

Schema coverage is 100% (baseline 3), but the description adds per-method required-parameter recipes, cross-parameter constraints (cash_flow_projections and contributory_asset_charges must be period-aligned; cash_flows_with/without must be equal length), the decimal convention for rates, and the omit-unused-kwargs rule. This meaningfully exceeds what the schema alone conveys.

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?

Opens with a specific domain (income approach) and enumerates the exact methods (relief from royalty, MPEE, single-period excess earnings, incremental cash flow, CAC), stating that 'method selects the formula'. It explicitly distinguishes itself from the dedicated asset valuation siblings, so an agent can place it without opening a schema.

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?

Gives explicit when-to-use routing: 'relief_from_royalty for IP with observable royalty rates', 'excess earnings for the residual intangible', and steers asset-specific work to valuation_customer/technology/ip/human_capital plus valuation_royalty_analysis, valuation_cost_approach and valuation_market_approach. Alternatives and their selecting conditions are named, not inferred.

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

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

Annotations already declare read-only/idempotent/no-open-world behavior, but the description adds real context beyond them: pure arithmetic with no I/O or external calls, rounding to 2 decimals, extra method-foreign parameters accepted and ignored, and an error returned for unknown methods or missing required params. It stops short of describing the returned structure, though an output schema exists.

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?

Purpose and sibling routing are front-loaded, and the per-method parameter lists are dense but useful. It is fairly long and re-states some schema facts (decimal convention, field names), which costs a little, but no sentence is purely wasteful.

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

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

For a 17-parameter tool with only one required field, the description supplies the missing method-parameter dependency map, error behavior, and unit conventions, and an output schema exists so return values need not be explained. An agent has everything required to call it correctly.

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

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

Schema coverage is 100%, so the per-parameter descriptions carry the baseline. The description's added value is the method→parameter mapping (which params each of patent/trademark/copyright/trade_secret requires and which are optional), a cross-parameter dependency the schema does not encode. It partially repeats schema content ('rates... are decimals', field names), so it is not a full 5.

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

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

States a specific verb and resource ('Use to value a specific IP right') and enumerates the four value types it computes (patent, trademark, copyright, trade-secret). It explicitly names the siblings it is not for (valuation_technology, valuation_customer, valuation_human_capital), so an agent can route without opening schemas.

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?

Gives explicit when-to-use ('value a specific IP right') and names the alternative tools plus the asset classes that select them (technology/software/data → valuation_technology; customer/workforce → valuation_customer / valuation_human_capital). Nothing is left to inference.

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

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

Annotations already declare readOnly/idempotent/openWorld=false, but the description adds genuinely new behavior: pure arithmetic with no I/O, rounding to 2 decimals, cross-method parameters accepted and ignored, and error semantics (unknown method or missing required param returns an error instead of a value). That is exactly the beyond-annotation context this dimension rewards.

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 the core purpose, then alternatives, then per-method parameter rules and behavioral notes. Dense but no sentence is wasted; the length is justified by two distinct formulas and seven method-dependent parameters.

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

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

A mutation-free, output-schema-backed arithmetic tool: the description covers formulas, parameter routing, units, rounding, ignored parameters, defaults, and error behavior. Nothing an agent needs to invoke it correctly is missing.

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

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

Schema coverage is 100%, so the baseline is 3, but the description goes further by mapping which parameters each method requires (comparable_transactions: comparables + subject_revenue; royalty_capitalization: revenue + royalty_rate + discount_rate), noting only method is required, explaining the {revenue, multiple} comparable shape, and restating the decimal convention. This resolves the method-dependent ambiguity the schema alone leaves open.

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

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

States a specific valuation method with the two formulas (comparable transactions multiples vs. royalty capitalization), and explicitly names the sibling tools that handle adjacent concerns (valuation_income_methods, valuation_royalty_analysis). An agent can distinguish this from its many valuation siblings without opening schemas.

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?

Gives an explicit when-to-use condition ('when reliable comparable transactions or royalty rates exist') and routes two nearby cases to named alternatives. This is the when/when-not/alternative pattern at full strength.

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 cover the safety profile (readOnly, idempotent, closed-world), and the description adds substantive behavior: pure arithmetic with no I/O, 2-decimal rounding, that off-method parameters are accepted and ignored, and that unknown methods or missing required params error out rather than returning a value.

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 purpose and then routing, with per-method parameter requirements grouped together. It is dense and somewhat long, but nearly every sentence carries distinct routing or parameter information; only minor tightening is possible.

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

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

For an 8-parameter, single-required-field tool with an output schema and full annotation coverage, the description supplies everything an agent needs: method-dependent parameter selection, unit conventions, error behavior, and sibling routing.

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

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

Schema coverage is 100% so baseline is 3, but the description goes well beyond the schema by mapping each method to the parameters it consumes (benchmark→ip_type+industry; adjust→base_royalty_rate+adjustment_factors; twenty_five_percent_rule→licensee_expected_profit), defining the multiplicative semantics of adjustment_factors, and fixing the decimal convention (0.10 = 10%).

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

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

States a specific verb+resource ('benchmark royalty-rate ranges… adjust a base rate… apply the 25% rule') and enumerates the three selectable methods. An agent can distinguish this from valuation_income_methods and valuation_market_approach without opening a schema.

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 scopes usage ('Use to select and support a royalty rate before a relief-from-royalty or royalty-capitalization valuation') and names the alternatives for the adjacent steps: valuation_income_methods (relief_from_royalty), valuation_market_approach (royalty_capitalization), and valuation_compliance for transfer pricing.

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, idempotentHint, openWorldHint=false and destructiveHint=false, so the safety profile is covered. The description still earns credit by adding non-obvious behavior: 'Pure arithmetic: no I/O and no external calls, rounded to 2 decimals,' the decimal convention for rates, the 1000-100000 iteration constraint for monte_carlo_sensitivity, and that unknown/missing-required-method inputs return an error rather than a value. This is useful context but not exhaustive (e.g. no detail on error shape or output rounding edge cases).

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?

Dense but front-loaded and well-organized: purpose first, then routing, then per-method parameter requirements, then conventions and error behavior. Every sentence carries distinct information (which method, which params, what defaults, what fails), with no filler.

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

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

For an 11-parameter, method-branching tool with an output schema present, the description covers the conditional parameter contract, decimal conventions, iteration bounds, default behavior for unused params, and failure modes. Nothing an agent needs to select a method and supply the right inputs is missing, and return-value explanation is correctly left to the output schema.

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

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

Although schema description coverage is 100%, the description goes well beyond the schema by mapping which parameters each method requires (e.g. monte_carlo needs input_distributions; decision_tree needs tree; sensitivity_analysis needs function_name + parameter_name + parameter_range + fixed_parameters), clarifying that only method is required and the rest are method-dependent, and stating the decimal-rate convention and iteration bounds. That conditional cross-parameter logic is not derivable from the flat schema alone.

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

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

The description opens with a specific resource ('Uncertainty analysis') and enumerates the four concrete methods (Monte Carlo valuation, sensitivity ranking, decision-tree EVs, one-at-a-time sensitivity), so the agent knows exactly what computation this tool performs. It also distinguishes itself from siblings by directing deterministic point valuations to 'the relevant valuation tool'.

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

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

Explicit routing: 'Use to quantify and stress the uncertainty around a point valuation,' contrasted with 'For a single deterministic point value use the relevant valuation tool,' and 'sensitivity_analysis varies one parameter of a core function only.' It also states the when-not condition for each method and notes params of other methods are ignored, leaving nothing to inference.

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

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

Annotations already mark this read-only, idempotent, closed-world and non-destructive, but the description adds substantially more: it is pure arithmetic with no I/O or external calls, results are rounded to 2 decimals, cross-method parameters are accepted and silently ignored, and an unknown method or missing method-required parameter returns an error rather than a value. That error/ignored-parameter contract is exactly the kind of behavior an agent needs and cannot get from 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 opening sentence and the sibling-routing sentence are well front-loaded, and the dense per-method parameter block earns its length given 18 parameters and 4 formulas. It is borderline long, but no sentence is filler; the slight deduction is for the run-on density of the per-method list.

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

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

With an output schema present, return values need not be explained, and the description covers everything else an agent needs: scope, alternatives, per-method required inputs, unit conventions, error behavior, and no-side-effect guarantees. Nothing material is missing for correct invocation.

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

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

Schema coverage is 100% and each parameter is described, but the description goes beyond it by mapping which parameters each method requires (e.g. developed_technology needs rd_costs + life_cycle_stage + competitive_advantage + discount_rate + cash_flow_projections) — information the flat schema cannot express. It also clarifies the decimal convention and that only 'method' is required while the rest are method-dependent and should otherwise be omitted.

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

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

States a specific domain (technology asset valuation) and enumerates exactly which intangible types it covers — developed technology, software, data assets, platforms — with the distinct methods each uses. It also explicitly names the sibling tools it is not for (valuation_ip, valuation_customer), so an agent can route correctly without opening a schema.

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?

Explicit when-to-use ('Use for developed technology, software, data, and platform intangibles') and when-not ('For patents, trademarks, copyrights, and trade secrets use valuation_ip; for customer relationships use valuation_customer'). Routing between alternatives is fully specified.

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 read-only/idempotent annotations, it discloses pure arithmetic with no I/O or external calls, two-decimal rounding, ignored non-matching parameters, and error behavior for unknown methods or missing required parameters. It also states the Gordon-growth constraint that discount rate must exceed perpetual growth rate.

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 purpose and usage, then lists method-specific parameters efficiently for a complex seven-method tool. It loses a point for repeating the decimal convention and mentioning 'premiums', which is not a parameter here, making one sentence redundant.

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

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

With an output schema present, the description need not explain return values. It covers method selection, parameter dependencies, decimal formatting, an edge-case constraint, error behavior, and sibling alternatives, giving an agent enough context to call the tool correctly.

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

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

Schema coverage is 100%, so the baseline is 3, but the description adds a per-method parameter map and clarifies that only method is required while other parameters are method-dependent and defaults apply where defined. It also explains decimal conventions and the discount_rate > perpetual_growth_rate constraint, though some of this repeats 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 names a specific finance operation: discounting/compounding single sums, valuing annuities and perpetuities, and computing terminal values. It distinguishes itself from valuation_income_methods and valuation_discount_rate, so an agent can tell what it computes without opening the schema.

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 when to use the tool, including moving cash flows through time or valuing a terminal value in a DCF. It also routes alternatives: uneven multi-period cash flows to valuation_income_methods and rate construction to valuation_discount_rate, and gives per-method parameter requirements.

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