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

With no annotations, the description carries the full burden and does disclose non-obvious behavior: the echoed request is fully RESOLVED, indices from build_curve results are added automatically, identical duplicates are collapsed, and conflicting ids are rejected. It omits side-effect/persistence information (whether bootstrapped curves are stored on the engine) and auth/error behavior, keeping it short of a 5.

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

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

The single-line purpose is front-loaded, followed by a scannable Args block and a short response note, so an agent can extract the essentials quickly. Density is high and RST-style quoting adds minor noise, but no sentence is filler given the 0% schema coverage.

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

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

Despite an output schema existing (which would excuse omitting return values), the description still explains the resolved request echo, the per-curve summary fields, and where sampled values live, closing the loop for the caller. Gaps remain around persistence, error semantics, and engine-version gating beyond the one calendar_overrides note, but for a six-parameter nested-reference tool this is close to 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 0%, so the Args block is doing all the work, and it documents every one of the six parameters with types, formats (YYYY-MM-DD for as_of), accepted union forms, and cross-tool provenance references (TermStructure, build_curve results, CurveQuerySpec, build_query results). It also adds semantics the schema cannot express, such as automatic index inclusion and duplicate/conflict handling.

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 opening sentence names a specific verb+resource pair ('Bootstrap curves on the engine and sample them') and pins the HTTP endpoint, so the agent knows this both constructs and evaluates curves. It implicitly separates from build_curve / build_value_curve by accepting their outputs as inputs, but never explicitly names a sibling it is not, so it falls short of full 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?

Usage is conveyed indirectly through the accepted input types: curves may be TermStructure objects, build_curve results, or session references, which tells the agent this is the sampling step downstream of build_curve/build_query. There is no explicit when-to-use vs when-not, and no routing language against bootstrap_inflation_curve or sample_vol_surface, so guidance remains implied.

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

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

With no annotations, the description carries the full burden. It usefully discloses that the body is validated first, sent as given once validated, and that preset support is absent, but it omits auth requirements, side effects, error behavior, and response handling.

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

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

The description is front-loaded with the endpoint and validation behavior, then lists Args efficiently. It is appropriately sized with little waste, though the docstring formatting is slightly mechanical.

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. The description covers parameters and validation, but for a raw engine endpoint it does not explain when to use this over close siblings such as engine_request or bootstrap_curve, leaving a gap in selection 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 0%, so the description must compensate. It documents both parameters: body is the raw engine BootstrapInflationCurvesRequest (with a pointer to engine_schema for its shape) and request_id maps to the optional X-Request-Id header.

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

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

The description states a specific action and resource: POST /bootstrap-inflation-curves with a raw body. It is clear what the tool does, but it does not differentiate from siblings like bootstrap_curve or engine_request, so it falls short of a 5.

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

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

The description gives no explicit when-to-use guidance or alternatives. It only notes that presets are not yet supported and points to engine_schema for the body schema, leaving the agent to infer when this tool is preferable to other curve-building or generic request tools.

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

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

With no annotations, the description carries the full burden and does so: it is a pure-local builder ('nothing is priced here', 'no engine call'), rejects duplicate (type, tenor) strips locally, and returns notes listing every default applied with its source. The market_data_source enumeration is further constrained in prose to exclude estimated/recalled/placeholder data.

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

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

Front-loaded with the one-line purpose, then an Args block that maps to the schema; nothing is filler. It is long, but the density is warranted for an 8-param builder with a polymorphic quote list, so only marginally 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 a preset-driven curve builder with defaults supplied by preset and an output schema present, the description covers the local-only nature, validation, default provenance, and where the result flows next. Nothing needed to call 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 description coverage is 0% at the top level, but the description documents every one of the 8 parameters in prose, including the per-type quote shapes (fra months_to_start/end, future price vs rate), the accepted tenor forms, and the exact semantics of each market_data_source enum value. This fully compensates for the coverage gap.

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

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

Declares a specific verb+resource ('Turn a quote strip into an engine curve spec') and immediately scopes it with '(no engine call)', which is exactly what distinguishes it from the sibling bootstrap_curve. An agent can pick it apart from bootstrap_curve, curve_from_pasted_table and build_value_curve 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?

It states when not to call ('If you would have to invent numbers, do not call this tool: ask the user for the data') and routes the output forward explicitly: indices to pass to bootstrap_curve or session_put. That is an explicit when/when-not/alternative set rather than implied 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?

With no annotations, the description carries the safety burden, and it does disclose the key behavioral fact that no engine call is made and that it returns {ok, query, notes}. It does not state whether the result persists, is executed later, or has any side effects, which leaves a gap for a builder that feeds a downstream 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?

It is front-loaded with the one-line purpose, then an Args block whose entries earn their place, closing with the return shape. The style is a dense docstring with clause-per-line, which is appropriate and wastes little.

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 8-parameter query builder, the description covers the parameters well and notes the return tuple, and an output schema exists so return details need not be expounded. The remaining gap is operational context (how the produced query is consumed and any constraints on it), which the sibling noise makes harder 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?

Schema description coverage is 0%, so the description must compensate, and it does substantially: it defines curve_id, the DF/ZERO/FWD measures, the tenors grid plus the calendar/business_day_convention requirement to roll tenors, the range_grid alternative, and the zero/fwd option blocks including the Period vs Instantaneous forward_type rule. Most of the 8 parameters gain meaning beyond the bare schema.

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

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

The opening line 'A CurveQuerySpec for bootstrap_curve (no engine call)' names the artifact produced and the parent operation, and the '(no engine call)' clause distinguishes it from the bootstrap_curve sibling. It is precise, though the jargon 'CurveQuerySpec' assumes domain familiarity rather than describing in plain terms.

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 '(no engine call)' note implies this is a construction step separate from bootstrap_curve, which is useful context, but the description never states explicitly when to reach for build_query versus calling bootstrap_curve or the other build_* siblings. Usage is implied, not spelled out.

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

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

With no annotations, the description carries the full burden and delivers substantive behavior: it will not hit the engine, the curve is anchored at the first point, discount requires the first point to be the reference date with value 1.0, forward supports only Linear/BackwardFlat/ForwardFlat, and compounding/frequency apply only to zero points. It omits the mutation/side-effect profile, e.g. whether the curve is registered under id in the session or whether an id collision overwrites.

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 is front-loaded in one sentence, then a tight Args block where nearly every line adds unique semantics. The market_data_source entry is long but each of its four values changes agent behavior, so it earns its space.

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, enum-heavy builder with no annotations, the description supplies conventions, defaults, cross-parameter constraints and a return shape. The remaining gap is statefulness — whether id registers the curve in the session and how duplicates are handled — which matters for a tool whose output includes a curve handle.

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?

Top-level schema coverage is 0% (only titles, no per-property descriptions), so the description must compensate and does: it documents id, kind semantics per enum value, point syntax with a concrete example, reference_date format, the preset-vs-conventions choice, compounding/frequency scope and defaults, and interpolator defaults per kind. This is richer than 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 first sentence names a concrete verb and resource ('interpolated curve from explicit values') and adds the discriminating clause 'no engine call', which separates it from engine-driven builders. It never names its closest siblings (build_curve, bootstrap_curve, curve_from_pasted_table), so the agent must infer the boundary itself.

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 a clear when-not rule ('If you would have to invent numbers, do not call this tool: ask the user for the data') and defines the four market_data_source situations that license a call. What it lacks is routing between siblings — nothing says when to prefer this over build_curve or curve_from_pasted_table.

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

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

With no annotations, the description carries the full behavioral burden. It usefully states that negative tenor_number shifts backwards, that end_of_month defaults to False, that calendar_overrides are per-request, and it gives the return shape. However, it does not cover error behavior, side effects, or whether the operation is purely computational.

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 well-structured, with a concise purpose line followed by an Args list. It is slightly redundant in restating the return summary even though an output schema exists, but the structure is front-loaded and readable.

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 7-parameter calculation endpoint with no annotations and an existing output schema, the description is largely complete: it documents every parameter and confirms the return object. The main gap is the absence of usage guidance relative to sibling calendar tools.

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

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

Schema description coverage is 0%, so the description must compensate, and it does: every top-level parameter is described with format, meaning, and defaults. Notable details include YYYY-MM-DD date format, negative tenor semantics, enum references for calendar/tenor_unit/convention, and the default for end_of_month.

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

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

The description states a specific verb and resource: 'Advance a date by a tenor on a QuantLib calendar'. This clearly distinguishes it from sibling tools such as calendar_holidays or calendar_business_days, and the HTTP endpoint reinforces its narrow 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 explains what the tool does but gives no explicit guidance on when to use it versus alternatives. There is no mention of prerequisites, when-not-to-use, or sibling tools like calendar_business_days.

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

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

No annotations are supplied, so the description carries the full behavioral burden. It does disclose that calendar_overrides are 'per-request' corrections and gives the returned summary shape ({count, first, last}), but it never states that this is a side-effect-free computation despite the POST-style endpoint, nor says anything about permissions or failure modes.

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 comes first in a single sentence, followed by a tight per-parameter block plus the output summary. No filler sentences; every line carries information an agent would otherwise have to guess.

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 6-parameter computation tool with an output schema and no annotations, the description covers the arguments, formats and return summary adequately. The remaining gap is routing guidance (when to use this vs. the other calendar tools), which is absent.

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, and it largely does: it documents all six parameters, supplies the YYYY-MM-DD formats the schema omits, and clarifies include_start/include_end semantics and their True defaults. It is only slightly thin on calendar_overrides, which the schema's $defs partly covers.

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

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

The description states a specific verb+resource: computing business days of a named QuantLib calendar between two dates, and even cites the underlying endpoint. It is distinguishable from siblings like calendar_holidays and calendar_advance by the 'between two dates' scope, though it never names those alternatives to sharpen the contrast.

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

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

There is no when-to-use guidance, no prerequisites, and no mention of when to prefer this over calendar_holidays or calendar_advance. Usage is only implied by the tool name and the argument list.

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

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

No annotations are provided, so the description carries the full behavioral burden. It does explain the include_weekends default and the calendar_overrides scoping ('applies to every use of that calendar while the request is processed and is discarded afterwards'), which is genuinely useful context. But it does not say whether this is a read-only operation, any auth or rate-limit behavior, or error conditions.

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

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

Front-loaded one-line purpose, then an Args block, then a brief note on summary. Efficient and well structured, though the trailing 'summary = {count, first, last} taken from the engine's response' sentence is low-value since an output schema exists.

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 five-parameter calendar query with an output schema and no annotations, the description covers the purpose, all five parameters with formats and defaults, and the transient nature of overrides. The remaining gap is the absence of any when-to-use routing against the two sibling calendar tools.

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

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

Schema description coverage is 0%, so the description must compensate, and it does: it documents calendar (with example enum values TARGET, UnitedStates), start_date/end_date as inclusive YYYY-MM-DD, include_weekends default False, and calendar_overrides structure with added/removed_holidays semantics including 'weekends are rejected'. Only the nested CalendarOverride contract is partially duplicated from $defs; the core five parameters get real added 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?

States a specific verb+resource: listing holidays of a QuantLib calendar between two dates, and even names the underlying endpoint POST /calendar-holidays. An agent can distinguish this from sibling calendar_business_days or calendar_advance 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?

Usage is implied by the resource (holidays between dates) and the endpoint hint, but the description never states when to prefer this over calendar_business_days or calendar_advance, nor prerequisites. Minimum viable guidance only.

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

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

With no annotations, the description must carry the full behavioral burden. It discloses only that the body is 'validated, then forwarded', which is a minor processing detail, but says nothing about permissions, cost, rate limits, or side effects of a calibration job.

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 sentence is front-loaded with the action and endpoint, which is good. However, it is dense with backtick-laden jargon, and the trailing summary-field list (hw_a, hw_sigma, rmse, num_helpers) is largely redundant given an output schema exists.

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 the return-value listing is unnecessary duplication. For a nested 0%-covered body, the description gives a reasonable structural sketch and points at examples, but an agent still lacks the concrete shape of the required body to invoke it confidently.

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% on a nested body object, so the description has to compensate. It partially does by naming the body contents ('pricing' with a SwaptionModelSpec in Calibrate mode, its 'hw_calibration' block, and 'model_id'), but it leaves request_id undocumented and the construction details deferred to external examples.

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

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

The description states a specific verb+resource: calibrating a Hull-White model to swaption vols, and pins it to the POST /calibrate-swaption-model endpoint. It is mostly distinguishable from siblings, though it never explicitly contrasts itself with calibrate_swaption_vol, which an agent could easily confuse it with.

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

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

There is no statement of when to use this tool versus alternatives such as calibrate_swaption_vol or price_swaption. The only routing hint is 'see the hwcal_* examples', which requires the agent to go look up another resource rather than deciding from the description.

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

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

With no annotations, the description carries the full behavioral burden. It usefully discloses validation against the vendored spec, forwarding, and that summary selects the calibration block, but omits auth requirements, side effects, persistence, idempotency, and error behavior.

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

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

The description is four dense sentences with the action front-loaded and no filler. Each clause adds invocation or body-construction value, including the endpoint and example reference.

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 described. For a complex nested POST with no annotations and 0% schema coverage, the description is only partially complete: it omits request_id semantics, auth, and side-effect/error details, though example references help an agent proceed.

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, and it does by naming key body fields (pricing with SwaptionSabrCalibrateSpec, vol_id, discounting_curve_id, forwarding_curve_id) and pointing to sabrcal_* examples. The request_id parameter remains undocumented, preventing 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?

Specific verb 'Calibrate' and resource 'SABR swaption cube' with endpoint POST /calibrate-swaption-vol make the action clear. However, it does not explicitly distinguish this from the sibling calibrate_swaption_model or clarify cube-versus-model calibration 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?

No when-to-use, when-not, or alternative guidance is provided. The only routing help is 'see the vol examples (sabrcal_*) for complete bodies', which aids invocation but does not explain when this tool should be chosen over sibling calibration or pricing tools.

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

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

With no annotations, the description carries the full burden and succeeds: it discloses that no engine call or modelling occurs, explains label matching rules (case- and punctuation-insensitive), specifies units, and details the return fields and diff formulas. This is rich behavioral context beyond the structured fields.

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 purpose is front-loaded in the first sentence, followed by structured Args and Returns sections. Although long, every sentence earns its place by documenting the complex mapping and diff logic required for correct invocation.

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

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

Given no annotations, 0% schema coverage, nested objects, and a complex comparison task, the description is complete. It even explains return values despite an output schema existing, and references `explain_method` for topic methodology, leaving no critical gaps.

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

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

Schema description coverage is 0%, so the description must compensate, and it does thoroughly: `external` is explained with an example, matching logic, and unit guidance; `quantra` is described as a pricing tool result or engine response, with which part is used. This adds substantial meaning absent from the schema.

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

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

The description states a specific verb and resource—'Put the user's numbers next to the engine's'—and explicitly differentiates from engine-calling tools with 'no engine call, no modelling'. An agent can immediately tell this is a comparison utility, not a pricing 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?

It provides implied usage context by describing the two parameter types (external numbers and an engine result), but never explicitly states when to use this tool versus the many pricing siblings or when not to use it. No alternatives or prerequisites are named, so an agent must infer the usage scenario.

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

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

With no annotations, the description carries the full behavioral burden and does so: it states 'No engine call; no arithmetic on the values,' identifies the id registration side effect, and documents edge-case behavior (the anchor point {reference_date: 1.0} added and reported in notes). It also discloses what the parse produces and how unparsed rows surface.

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 the one-line purpose before an Args block, and every sentence is load-bearing given thirteen undocumented parameters. The terse notation keps it dense without padding; nothing reads as 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 a high-complexity curve-construction tool with 13 params, 0% schema coverage, and no annotations, this covers input syntax, routing, provenance constraints, and return behavior. The output schema exists, yet the description still orients the agent to the return shape and notes without that being required.

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% across 13 parameters, so the description must compensate entirely — and it does, documenting text separators, accepted date formats, % and comma handling, per-row type tags, the three kind values, every market_data_source value, preset vs conventions, reference_date omission rules, quote_type fallback, percent, date_format inference, and compounding/frequency scope per kind.

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 — it parses a user-pasted table and routes it to build_value_curve or build_curve — and explicitly names the two builder siblings, so an agent can distinguish it from them without opening a schema. The parenthetical examples (vendor screen, spreadsheet, ticket) make the input source 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?

Gives a clear use context and a strong explicit when-not rule: 'If you would have to invent numbers, do not call this tool: ask the user for the data,' plus a typology of market_data_source with the meaning of each value. It does not explicitly say when to prefer calling build_value_curve directly with clean values, so routing vs the sibling builders is left partly 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?

With no annotations, the description carries the full burden and does so: the engine does not default omitted fields, validate=True blocks sending on schema failure with per-JSON-pointer problems, request_id is auto-generated and echoed in engine.request_id, and error semantics are given verbatim (400 = request wrong, 422 = well-formed but unpriceable). This is exactly the kind of behavioral context annotations would otherwise supply.

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 one-line summary is front-loaded before the Args and Returns sections, and every sentence carries actionable information – no filler, no restatement of the name. Dense but well-organized with clear sectioning.

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 generic passthrough tool with a nested free-form body, the description covers input discovery, validation, error taxonomy, and return shape. Although an output schema exists (so return values needn't be explained), the added ok/status/error semantics are useful and nothing required for correct invocation is missing.

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

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

Schema description coverage is 0%, so the description must compensate, and it documents all four parameters: endpoint with a concrete path example, body as the full request object with pointers to where its shape is defined, validate's default and failure behavior, and request_id's optional X-Request-Id forwarding. No parameter is left ambiguous.

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

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

Opening sentence gives a specific verb (POST), resource (JSON body to an engine endpoint), and positions it precisely among siblings as 'the raw escape hatch', immediately distinguishing it from the high-level price_* tools. An agent can tell what this is 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?

The 'raw escape hatch' framing plus pointers to list_endpoints, engine_schema, and quantra://examples/* resources tell the agent how to discover valid inputs and when this low-level tool is the right call. It stops short of an explicit when-not (e.g. 'prefer price_ois_swap for standard swaps'), leaving that inference to the agent.

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

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

No annotations, so the description carries the burden, and it does disclose unusual behavior: depth controls $ref inlining, deeper refs are marked with '{"$ref": ..., "unresolved": true}', unknown endpoints error with a valid-list, and the engine rule that omitted-but-needed fields are an error, not a default. Missing only auth/rate-limit notes.

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 purpose sentence, then Args and Returns sections. The docstring layout is slightly awkward inside a description field and the 'Remember the engine's rule...' line reads as an addendum, but every sentence carries 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?

An output schema exists, so return-value detail is not required, yet the description still summarizes what comes back (top-level required list, field names, both schemas). Combined with error behavior and the no-implicit-defaults rule, an agent has enough to call this correctly.

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

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

Schema description coverage is 0%, so the description must compensate, and it largely does: endpoint is characterized as one of 24 POST paths with leading slash optional, and depth is given a range (0..8), a default (3), and concrete behavior for values that exceed inlining. It stops short of enumerating or pointing at list_endpoints for valid names.

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

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

Names a specific verb+resource: fetch request/response JSON schema for one engine endpoint. An agent can distinguish it from engine_request (which calls the endpoint) and list_endpoints (which enumerates names), though the description never states those distinctions explicitly.

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

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

Gives usable context: 'one of the 24 POST paths' and the failure mode for unknown names (an error listing valid endpoints). But it never says when to reach for this versus list_endpoints, engine_request, or get_example, leaving routing 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?

With no annotations, the description carries the full burden and does disclose notable traits: engine pages make an engine-backed lookup while `connector-analytics` involves 'no engine call', returns include a `not_documented` list (transparency about limitations), and it surfaces provenance. It does not discuss cost, latency, or whether the output is cached, so a small gap remains for a documentation 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 the purpose, then well-structured Args/Returns blocks with no filler sentences. The long comma-separated topic list and the closing citation-discipline sentence make it denser than ideal, but every part carries 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?

Even though an output schema exists, the description still names the returned keys (markdown, citations, links, repository, not_documented, repos), tells the agent what a page contains, and enumerates valid inputs. Nothing an agent needs to select or invoke this 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 0% and the schema has only `topic: string`, so the description compensates fully by enumerating every valid value (npv, fair-rate, greeks-bump-and-reprice, … error-codes, plus connector-analytics) and explaining what the analytics value means. This is meaning that exists nowhere in 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?

States a specific verb (explain) and resource (how the engine computes a method / how this server derives its analytics), and explicitly separates the engine-page topics from the `connector-analytics` topic that describes what sibling tools like swap_dv01 and key_rate_ladder compute. An agent can distinguish this from price_* / build_* siblings 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?

Gives clear context: use it for cited engine/connector documentation, and it explicitly routes the analytics question to the `connector-analytics` topic rather than an engine page. It also prescribes behaviour ('quote the citations or hand over the links when you explain a number; never assert a cause the page does not support'), though it does not give explicit when-not-to-use 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?

With no annotations, the description carries the full burden and does disclose non-obvious behavior: results are passed through from the engine, nothing is solved locally, and when the response lacks fair_rate/fair_spread the provided_by_engine flag is false with an explanatory message. It does not spell out read-only status, required engine/session prerequisites, or any rate/permission constraints.

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 core purpose is front-loaded in the first sentence, followed by Args and Result sections that are easy to scan. The market_data_source enumeration is verbose but each entry carries decision-relevant meaning, so little is wasted.

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 6-parameter tool with nested objects and an output schema, the description covers the one parameter the schema leaves opaque (market_data_source) and the pass-through/failure behavior an agent would otherwise guess wrong. The remaining gap is that trade/market/as_of semantics are delegated to swap_dv01 rather than restated. Since an output schema exists, not describing return fields is acceptable.

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?

Top-level schema coverage is 0%, so the description must compensate. It explains market_data_source thoroughly (all four provenances plus what has no valid value), but market, trade, and as_of are dismissed with 'as in swap_dv01', deferring to another tool rather than adding semantics here. The nested SwapSpec $defs do carry some documentation, so coverage is partial rather than absent.

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 and action: the fair (par) rate of a swap, read from the engine's pricing response. It also cross-references swap_dv01 for the argument shape, which orients the agent within the family. It stops short of distinguishing when fair_rate is preferred over the sibling pricers (price_vanilla_swap, price_ois_swap), so it is clear but not fully 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 market_data_source enumeration effectively encodes when-to-use conditions (user_pasted / user_file / engine_example / session), and the explicit exclusion 'If you would have to invent numbers, do not call this tool: ask the user for the data' is a clear when-not-to-use rule. No alternative sibling tool is named as a substitute, so it falls short of an explicit routing statement.

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

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

With no annotations, the description carries the full burden and usefully discloses that the example is vendored and makes no engine call. It also describes the returned components, though it does not explicitly label the operation as read-only or mention any access constraints.

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 compact and front-loads the core purpose before explaining how to use the result. The second sentence is dense but earns its place by giving concrete invocation patterns.

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 fully documented, and the description does explain the main returned fields. Still, it leaves the required name parameter undocumented and does not help an agent decide between this tool and sibling example/preset tools.

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

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

The schema has 0% description coverage for the single required parameter name, and the tool description never explains what the name refers to or what format it expects. The description adds no meaning beyond the bare schema title.

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 returns one vendored example, including endpoint, catalog description, reference value, and complete request body. It implies a single-item retrieval, distinguishing it from list_examples, but does not explicitly name or contrast 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?

It gives concrete post-retrieval usage: feed the output to engine_request(endpoint, body) or pass body["pricing"] as the market for a pricing tool. However, it does not state when to choose get_example over alternatives such as list_examples or get_preset.

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

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

No annotations are provided, so the description carries the behavioral burden. It conveys that this is a read returning structured preset data, but does not state what happens for an unknown id, whether presets are immutable or session-scoped, or any auth/rate considerations. Adequate but incomplete for a zero-annotation tool.

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

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

The summary sentence is front-loaded and dense with useful detail, and the Args block is short. The example list is a touch long but each entry earns its place by demonstrating the id pattern.

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 needn't explain return values, yet it does sketch them, and the id examples cover the only parameter. For a one-parameter lookup this is nearly sufficient; the missing usage routing is the main gap.

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

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

Schema description coverage is 0%, so the description must compensate, and it does by giving six concrete id examples (USD_SOFR_OIS, EUR_ESTR_OIS, GBP_SONIA_OIS, EUR_EURIBOR_6M, etc.) that reveal the naming convention. It does not say whether ids are case-sensitive or where the canonical list comes from, but the examples add real value.

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

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

States a specific resource (one preset) and enumerates its contents (index definition, curve settings, helper convention blocks, field provenance), which is far more informative than the bare name. It does not explicitly name list_presets as the plural sibling it differs from, so it falls short of the 5 bar.

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

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

There is no statement of when to use this versus list_presets or the various build/bootstrap/calibrate tools. The Args block documents the id, not the usage context, so an agent must infer the retrieval scenario entirely.

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

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

With no annotations, the description carries the full behavioral burden, and it does disclose useful traits: the exact reprice count (1 + 2 + 2 x pillars), concurrent execution bounded by QUANTRA_MAX_CONCURRENCY, and strict market_data_source semantics. It never states side effects or persistence (e.g., that the run is a pure read, or what a 'session' source implies about prior writes), leaving the safety/profile picture incomplete.

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 one-line purpose, then cleanly split into Args and Result sections; the densest material is the market_data_source paragraph, which earns its space as a usage guard. The 'as in swap_dv01' shorthand is efficient, though the result-format sentence is long enough to need rereading.

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 restated, yet the description still names the ladder/parallel/sum_of_buckets/definitions/calls fields, and it covers the provenance, curve-selection, and cost-of-call dimensions an agent needs. The remaining gap is the opaque market payload and override object, which neither schema nor description clarifies.

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?

Top-level schema description coverage is 0% across 9 parameters, so the description must compensate. It fully defines market_data_source (all four enum values with provenance meaning), explains curve's default and that buckets are the curve's ACTUAL points in wire order, and defers market/trade/bump_bp/method/as_of to swap_dv01. The market object (open additionalProperties), request_id, and calendar_overrides remain entirely unexplained, 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?

States a specific computation (key-rate DV01 ladder = one bump per curve pillar plus a parallel bump), which is a concrete verb+resource+scope rather than a restated name. The reference to swap_dv01 for shared arguments implicitly positions it as the bucketed counterpart of swap_dv01, but the contrast is not spelled out explicitly.

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

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

Gives an explicit when-not rule tied to data provenance: 'If you would have to invent numbers, do not call this tool: ask the user for the data,' plus the rule that engine_example is only valid when the user asked for an example. It does not, however, say when to choose this over swap_dv01 or scenario.

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

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

With no annotations present, the description carries the load and does disclose a key behavioral trait: the data comes from a vendored spec rather than the live engine, so it may be stale, and the endpoint count is pinned to a version. It could say more about the read-only/list nature, but the staleness disclosure is genuinely valuable.

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 short sentences, front-loaded with what the tool returns and followed by the provenance caveat. The mid-sentence backtick and line breaks are slightly awkward but no sentence is wasted.

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-value detail is not required. For a zero-parameter listing tool, the description covers what is returned, its source, and the version-mismatch caveat, leaving little an agent would need 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?

The tool takes no parameters, so there is nothing for the description to explain beyond the schema; baseline 4 applies. The schema is empty and fully described by its own structure.

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: it lists the engine's POST endpoints with one-line descriptions, and adds the provenance (vendored OpenAPI spec). It doesn't explicitly differentiate itself from close siblings like list_enums or engine_schema, which also expose engine metadata, so it falls short of a 5.

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

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

The description implies a use case (checking available endpoints, and comparing with quantra_meta to detect a version mismatch) but never states when to use this versus list_enums or engine_schema, nor any preconditions. Usage is inferable rather than explicit.

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

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

With no annotations, the description carries the full behavioral burden. It discloses the error behavior for unknown names, which is helpful, but does not explicitly state that this is a read-only, side-effect-free operation or address any auth/rate considerations, leaving some transparency gaps.

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

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

The description is front-loaded with the purpose and then uses an Args block for parameter examples. It is appropriately sized with no filler, though the trailing newline and minor structural choices keep it from being maximally polished.

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 low complexity, a single string parameter, and the existence of an output schema (which handles return values), the description covers purpose, parameter examples, and error behavior sufficiently. It lacks explicit sibling differentiation and safety notes, but nothing critical for correct invocation is missing.

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

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

Schema description coverage is 0%, so the description must compensate for the single parameter. It does so effectively by listing concrete example enum names (Calendar, DayCounter, Frequency, etc.) and explaining the error behavior for unknown values, adding meaningful semantics beyond the bare schema.

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

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

The description states a specific resource ('engine enum') and action ('values of'), making it clear that this tool returns enum members from the engine spec. It does not explicitly differentiate from siblings like engine_schema or list_endpoints, so it falls short of a 5, but the purpose is unambiguous.

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

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

Usage is implied: the tool returns enum values and the description explains that an unknown name returns an error listing every available enum, which is a useful discovery path. However, it gives no explicit when-to-use guidance or alternatives compared to sibling tools, leaving the agent to infer suitability.

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

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

With no annotations, the description carries the burden and does so reasonably: it declares the operation makes no engine call (i.e. no side effects), and discloses the row shape including the 'reference_text' assertion value and resource 'uri'. Pagination, ordering, and error behavior on unknown categories are not covered.

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 purpose sentence, then structured Args and return-row enumeration. The long fixture lists are long but earn their place as the only valid-value documentation; minor redundancy in listing row fields when an output schema exists.

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

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

For a zero-required-param, zero-schema-coverage discovery tool, the description supplies the value domain, the semantic difference between the two filters, the return shape, and the handoff to get_example. Despite an existing output schema, restating the row fields is harmless reinforcement rather than a gap.

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

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

Schema description coverage is 0% and neither param has an enum, so the description is the only source of meaning — and it supplies it, enumerating 17 valid category fixtures and a set of product endpoints, plus clarifying that product is an alternative filter axis. This is substantial value 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?

States a specific verb and resource ('List the vendored engine example requests') and immediately scopes it against the engine-calling siblings with '(no engine call)'. An agent can distinguish this catalog-listing tool from engine_request and get_example 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?

Explicitly frames this as a non-executing listing and names the follow-up tool ('get_example(name) returns the body'), routing the agent from discovery to retrieval. It does not spell out when to prefer list_examples over list_endpoints or list_presets, so full alternatives guidance is absent.

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

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

No annotations are provided, so the description carries the burden. It discloses the returned row structure (id, currency, index, helpers, curve, provenance) and clarifies helpers' meaning, but does not state read-only nature or any auth/pagination behavior. Solid but not exhaustive.

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 tight sentences: purpose, row fields, and a pointer to get_preset. Front-loaded and every sentence earns its place without redundancy.

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

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

For a zero-param list tool with an output schema, the description covers purpose, context, and data shape. It omits ordering/pagination details, but those are minor and the output schema already covers 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?

The tool has zero parameters, so the baseline is 4. The description adds no parameter info, and none is needed.

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

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

Specific verb (list) + resource (presets) + scope (market-convention presets for build_curve/build_value_curve). It contrasts with get_preset, which returns the actual data, so an agent can distinguish them 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?

Identifies downstream consumers (build_curve/build_value_curve) and names get_preset as the tool that returns preset data, implying a list-then-fetch workflow. No explicit when-not or exclusion, so 4.

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

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

No annotations are provided, so the description carries the full behavioral burden. It does valuable work disclosing that estimated/recalled/placeholder market data is forbidden and that session-sourced data must trace to a real origin, but says nothing about permissions, idempotency, or pricing side effects, and does not describe the response.

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 endpoint, then an Args block that is organized and scannable. It is fairly long, and the delegation sentence is terse, but no sentence is pure 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 18-parameter, 9-required, nested-object tool with no annotations, the description is only partially complete. An output schema exists so return values need no explanation, but the many undocumented parameters and absent behavioral notes leave 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?

Top-level schema description coverage is 0%, so the description must compensate. It well documents market_data_source, and covers preset, call_schedule shape, model and tree_steps, but leaves the majority of the 18 parameters (face_amount, coupon_rate, discounting_curve, market, overrides, etc.) to an external reference ('as in price_fixed_rate_bond').

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 (price) and resource (callable / puttable fixed-rate bond) plus the method used (Hull-White lattice) and the underlying endpoint. An agent can distinguish it from price_fixed_rate_bond by the callability dimension.

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 market_data_source paragraph gives explicit when-not-to-use guidance ('If you would have to invent numbers, do not call this tool: ask the user for the data') and constrains the engine_example path. It delegates remaining argument semantics to price_fixed_rate_bond, but does not state callable-vs-plain alternative routing explicitly.

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

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

With no annotations, the description carries the full burden and does well: it discloses that the tool injects an OptionletVolSpec and a CapFloorModelSpec into the market, that base conventions are inherited from the preset, that unspecified schedule fields default from the preset, and that estimated/recalled data is disallowed. It omits failure behavior and curve prerequisites, which keeps it from a 5.

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 a one-line purpose before the Args block, and the per-parameter lines are tight. It is long, but the length is justified by 23 parameters and enum/format details that are not in the 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?

For a 23-parameter, 11-required tool with nested objects and no annotations, the description supplies the conventions, defaults, and sourcing rules an agent needs to call it correctly; return values are covered by the output schema. Curve-related parameters and error handling remain undocumented.

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?

Top-level schema coverage is 0%, so the description must compensate, and it defines the semantics of roughly a dozen parameters (vol structure, model options, preset names, schema override defaults, include_details). However, several of the 23 parameters (discounting_curve, forwarding_curve, index_id, as_of, market, additional_trades, calendar_overrides) receive no explanation.

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

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

States a specific verb and resource ('Price an interest-rate cap, floor or collar') and even names the endpoint. An agent can immediately distinguish it from siblings like price_swaption or price_yoy_inflation_cap_floor.

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 market_data_source argument defines four legitimate sourcing modes and explicitly states when NOT to call the tool ('If you would have to invent numbers, do not call this tool: ask the user'). It stops short of routing between alternative pricing tools, but the invocation conditions are unusually explicit.

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

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

No annotations are supplied, so the description must carry the behavioral load; it discloses the default preset and its conventions, that par-spread curves are bootstrapped by the engine, default recovery rate, the CdsModelSpec id pattern (cds_<type>), and defaults for optional dates. It says nothing about permissions/auth, but for a pure compute endpoint that gap is minor.

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 the one-line purpose followed by a structured args block; given 26 parameters, most lines earn their place by supplying defaults or accepted value forms. Slightly long, but not padded.

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 needn't be re-explained (the brief summary.cds_list note is a bonus). Against 26 params, 7 required, zero schema coverage and no annotations, leaving the required 'market' object and 'discounting_curve' id undocumented is a real gap for correct invocation.

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

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

Schema description coverage is 0% at the top level, so the args list does the heavy lifting and explains most parameters (market_data_source in depth, side, notional, running_coupon units, the three credit_curve forms, preset, start/maturity/tenor, recovery_rate, model, and the optional schedule fields). However, required parameters 'market' and 'discounting_curve', plus as_of, additional_trades and calendar_overrides, are left entirely unexplained, so it doesn't fully compensate for the coverage gap.

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

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

Opens with a specific verb+resource ('Price a single-name CDS') plus the underlying route POST /price-cds, which cleanly separates it from the many sibling pricing tools (price_vanilla_swap, price_swaption, price_ois_swap, etc.). An agent can identify the tool's scope 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?

The market_data_source enumeration gives explicit provenance rules (user_pasted/user_file/engine_example/session) and a clear when-not-to-use rule: 'If you would have to invent numbers, do not call this tool: ask the user for the data.' It does not name sibling tools or say when to prefer related tools, so it falls short of the 5 bar.

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

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

With no annotations, the description carries the full burden and does disclose meaningful side effects and constraints: the tool adds Price quotes / zero curves / vol specs to the market, dividend_yield is mandatory because "the engine requires a dividend curve id on every underlying", as_of is required without a market, and exercise-window defaults are spelled out. Auth, permissions and any limits are unstated.

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 purpose, then a tightly formatted Args block; sizing is appropriate for a 22-parameter tool. Minor waste in restating the trailing summary.options fields even though an output schema exists.

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 high-complexity tool with no annotations, the description covers the market-data provenance rule, defaults, reference-by-id semantics and exercise conventions, and the output schema carries the return contract. The remaining gap is the handful of undocumented secondary parameters.

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?

Top-level schema description coverage is 0%, so the description must compensate, and it does for most parameters: all market_data_source enum values, the vol/rate_curve/dividend_yield shapes, preset default (EUR_EQUITY), exercise variants, model options and discrete_dividends. Still silent on quantity, trade_id, underlying_id, additional_trades and calendar_overrides.

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 verb+resource ("Price a vanilla equity option") plus the underlying endpoint, which is enough to separate it from the many sibling pricers (price_vanilla_swap, price_swaption, price_cap_floor, etc.) without reading the schema. Nothing vague or tautological.

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-not guidance for market_data_source ("There is no value for estimated, recalled or placeholder data. If you would have to invent numbers, do not call this tool: ask the user for the data") and explains the id-vs-inline reference choice for vol, rate_curve, dividend_yield and model. It does not, however, route the agent to sibling helpers (build_curve, build_query, curve_from_pasted_table) when a curve/surface must be constructed first.

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

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

With no annotations, the description carries the full burden and does disclose meaningful behavior: default effective_date = issue_date, the 'spot' resolution for issue_date, engine-resolved tenor, and the data-provenance policy. It omits error/side-effect behavior, but the compute-only nature and rich defaults make this solidly above average.

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 is front-loaded, then a compact Args list where nearly every line carries semantic value (formats, defaults, constraints). It is dense rather than padded, though the market_data_source paragraph is long relative to the rest.

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 18-parameter tool with nested objects and an existing output schema (so returns need not be explained), the description covers the critical inputs and even summarizes summary.bonds. Remaining gaps (as_of, additional_trades, calendar_overrides semantics) are minor but present.

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, and it documents ~13 of 18 parameters (market_data_source, preset, face_amount>0, coupon_rate as annual decimal, date formats, discounting_curve, overrides, yield_overrides, include_* flags). It leaves as_of, top-level tenor, request_id, additional_trades, and calendar_overrides unexplained, and defers market format to price_vanilla_swap.

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 first line gives a precise verb+resource ("Price a fixed-rate bond") plus the backing endpoint, which cleanly separates it from siblings like price_floating_rate_bond or price_zero_coupon_bond. It never explicitly states what it is not, so it stops short of a 5.

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 market_data_source block supplies real when-to-use/when-not guidance, including the hard exclusion "If you would have to invent numbers, do not call this tool: ask the user for the data" and the restriction of engine_example to explicit user requests. It does not, however, help the agent choose between the many price_* siblings.

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

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

No annotations are provided, so the description carries the full burden, and it discloses real behavior: fixing_days and in_arrears default from the preset, index_id defaults to the preset's, and when coupon_pricer is omitted the tool injects the preset's zero-vol BlackIborCouponPricer. It also defines the four market_data_source modes and forbids estimated/recalled data. Remaining gaps (permissions, failure modes) are minor for a non-mutating pricing call.

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 is front-loaded in one line, followed by a scannable Args list that groups FRN-specific params first and defers shared ones by reference instead of repeating them. The market_data_source entry is long but each mode earns its place because it governs whether the call is even legal.

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 22-parameter tool with nested objects and no annotations, the description covers the domain-specific pieces well and correctly leaves return values to the existing output schema. The gap is the unmentioned required curve/market inputs and undocumented optional plumbing (as_of, calendar_overrides, request_id), which an agent must infer from schema names alone.

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 has to compensate, and it does for the FRN-specific params (spread as decimal, index_id default, fixing_days/in_arrears defaults) and market_data_source in detail. However, required params such as market, discounting_curve, and forwarding_curve are never mentioned, and as_of, calendar_overrides, additional_trades, and request_id are left entirely undocumented, so roughly a third of the 22 params get no help.

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 ('Price a floating-rate note') and pins the HTTP endpoint, and the argument list makes the FRN-specific surface (spread, index_id, fixing_days, in_arrears, coupon_pricer) explicit against the sibling price_fixed_rate_bond it defers to. Differentiation from price_zero_coupon_bond / price_vanilla_swap is clear from the resource name, though the contrast with price_fixed_rate_bond is only implied by the cross-reference rather than stated.

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-not rule ('If you would have to invent numbers, do not call this tool: ask the user for the data') and a prerequisite for the preset ('a preset with a floating_rate_bond block'). It does not name alternative sibling tools or say when a different pricing tool is the better pick, so it falls short of the 5 tier.

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

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

No annotations exist, so the description carries the full burden, and it delivers real behavioral context: market_data_source provenance rules, the engine's three calendar-advance resolution of spot and 3M/6M, and the note that those advances are echoed. It does not discuss error conditions or the assumption behind curve inputs, so not quite 5.

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 structured as an Args block, with a compact return-value note at the end. The market_data_source definition is verbose, and enumerating redundant sub-cases costs some density, but nearly every line earns its place.

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

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

For a 19-parameter pricing tool with no annotations but with an output schema, the description covers provenance, date resolution, curve expectations and returns (summary.fras fields). An agent has enough to invoke correctly without external documentation.

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, and it does: it defines market_data_source's four values, preset requirements (fra block, named presets), the sign of notional, strike as a decimal forward rate, side semantics matching the enum, and the months/dates duality including the 3x6 example. This is far beyond the bare schema titles.

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 ('Price a forward rate agreement') and anchors it to the endpoint POST /price-fra. Among many 'price_*' siblings, it is immediately distinguishable as the FRA pricer.

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/why-not through the market_data_source enumeration, and critically tells the agent not to call the tool when it would have to invent numbers, routing it to ask the user instead. This is unusually strong routing guidance.

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

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

With no annotations, the description carries the full burden. It usefully discloses that the overnight-leg parameters default to the preset's values (including concrete preset examples like payment lag 2 for USD_SOFR_OIS) and warns against inventing market data, but says nothing about auth, rate limits, or error behavior. Since an output schema exists, return values need not be explained.

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 is front-loaded and the Args block is scannable, but the repeated 'as in price_vanilla_swap' cross-reference saps self-containedness and forces the agent to consult another tool definition to resolve most 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?

For a 26-parameter tool with nested objects, the description covers roughly half the surface and delegates the rest to a sibling. The output schema handles return values, and the market_data_source guidance is thorough, but the unexplained parameters and heavy reliance on price_vanilla_swap leave notable gaps.

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

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

Schema description coverage is 0% across 26 parameters, so the description must compensate. It does add real meaning for market_data_source, preset, and the overnight-leg parameters, but punts ten-plus parameters (market, swap_type, notional, curves, overrides, etc.) to 'as in price_vanilla_swap' and never mentions calendar_overrides or request_id at all.

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 ('Price an OIS (fixed vs compounded overnight) swap') plus the endpoint. The parenthetical definition of an OIS clearly separates it from sibling pricing tools such as price_vanilla_swap and price_fra.

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-not ('If you would have to invent numbers, do not call this tool: ask the user for the data') and enumerates the valid market_data_source values, which is strong routing guidance. However, it never explicitly contrasts this tool's purpose against price_vanilla_swap beyond deferring parameter docs to it.

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

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

With no annotations, the description carries the full burden and does substantial work: it explains that settlement_type Physical derives the method from the preset while Cash requires settlement_method, that 'spot' effective_date is engine-resolved via preset settlement days, that built surfaces are wrapped in SwaptionVolSpec with the preset's swap_index_id, and what include_details/include_diagnostics add. It still omits what the market dict must contain and any failure/reversibility 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?

Structured as a compact, dense Args list where each line addresses a distinct parameter or behavior; little is wasted. It is not front-loaded with a usage summary and the inline cross-references (engine enum names, preset block names) make it long, but the density is justified by a 20-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?

An output schema exists, so the brief mention of summary.swaptions (npv, implied_volatility, atm_forward, annuity) is sufficient. For a tool at this complexity, though, leaving three required inputs (market, discounting_curve, forwarding_curve) entirely unexplained is an incompleteness an agent will notice at call time.

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?

Top-level schema description coverage is 0%, so the description must compensate, and it does explain roughly half the arguments well (market_data_source, preset, underlying, exercise_date(s), vol, model, include_details, include_diagnostics). But required arguments such as market, discounting_curve, forwarding_curve and as_of, plus additional_trades and calendar_overrides, are never described, leaving significant 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?

Opens with a specific verb+resource ('Price a swaption') plus the underlying endpoint. Against a sibling list containing price_vanilla_swap, price_cap_floor and calibrate_swaption_vol, an agent can immediately tell this is the swaption *pricing* (not calibration) 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?

Gives an explicit exclusion: 'If you would have to invent numbers, do not call this tool: ask the user for the data,' and constrains engine_example to 'only when the user explicitly asked to run an example.' However, it never routes to the obvious alternatives (calibrate_swaption_vol, calibrate_swaption_model, price_vanilla_swap) or states prerequisites like a stored market being required first.

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

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

With no annotations, the description carries the full burden and does substantial work: it discloses market-data provenance rules, the /calendar-advance date resolution, defaults (spread 0.0, preset index), and the response shape (notes, date_resolution, summary.swaps). It stops short of stating the operation is side-effect free/read-only or whether it requires session state or auth, which an annotation would normally cover.

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 is front-loaded and the Args block is well structured with each line earning its place given the 0% schema coverage. The trailing "Result" paragraph is mildly redundant since an output schema exists, and the block is long, but length here is justified by parameter breadth.

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 20-parameter, nested-object, packed-structure tool the description is nearly complete: provenance, dates, curves, overrides, batching, and return shape are all covered. Remaining gaps are the unmentioned request_id/calendar_overrides and the absence of any pointer to related tools (fair_rate, swap_dv01, reprice_with) an agent might need next.

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

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

Schema description coverage is 0% but the Args block documents the overwhelming majority of the 20 parameters with formats, defaults, and value semantics (e.g. fixed_rate "decimal, e.g. 0.032", effective_date "spot", swap_type Payer/Receiver, overrides meaning, additional_trades batching). Only request_id and calendar_overrides go unmentioned, which is a trivial gap given the otherwise dense compensation.

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 verb+resource ("Price a fixed-vs-IBOR swap") plus the underlying endpoint, which cleanly separates it from the sibling pricing tools like price_ois_swap and price_fra. An agent knows exactly what instrument is being valued 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?

Strong conditional guidance for market_data_source (user_pasted vs user_file vs engine_example vs session) and an explicit when-not: "If you would have to invent numbers, do not call this tool: ask the user for the data." However it never routes to alternative pricing siblings such as fair_rate, swap_dv01, or reprice_with, so cross-tool selection is left 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?

No annotations are supplied, so the description carries the full behavioral burden. It does disclose useful behavior beyond the schema: the vol spec 'the tool adds with the preset's conventions', the conditional role of cap_rate vs floor_rate, and the data-provenance contract. But it says nothing about compute cost, error behavior, or mutation/state effects, leaving real gaps for a pricing tool with zero annotation coverage.

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 the two param-critical notes, then the provenance contract. Efficient prose overall, though the market_data_source paragraph is long and could be tightened by listing the four enum values against their meanings more compactly.

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 does not need to explain return values. It supplies the crucial inputs and the invocation constraint for this 23-parameter tool, leaving only the obvious scalar fields implicit.

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 and largely does for the non-obvious parameters: it documents fixings (required, format per price_yoy_inflation_swap), the vol object shape and enum values, the surface-id alternative, and the cap_rate/floor_rate conditioning. The many self-explanatory params (notional, spread, gearing, dates, curves) are left to their names, which is acceptable.

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 verb (Price), a specific resource (year-on-year inflation cap / floor / collar), and the underlying endpoint. It also distinguishes itself from the sibling price_yoy_inflation_swap by naming the instrument difference and referencing the sibling for the shared fixings format.

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 a clear exclusion ('If you would have to invent numbers, do not call this tool: ask the user') and detailed provenance guidance for market_data_source, including when engine_example is allowed ('only when the user explicitly asked to run an example'). It does not, however, explicitly route between this tool and price_cap_floor or price_yoy_inflation_swap, so the alternatives comparison is only partial.

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

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

With no annotations provided, the description carries the burden and does add real context: the market must carry a YoY inflation index and YoYInflation curve, fixings are REQUIRED, and fixed/YoY legs share the preset schedule. However it is silent on permissions, error behavior, and what the pricing result contains (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?

Front-loaded with the purpose and endpoint, and formatted with a clear Args section. The market_data_source block is verbose and repetitive, while other equally complex parameters get no prose at all, so the space allocation is unbalanced.

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 21-parameter, 9-required tool with 0% schema coverage and no annotations, the description explains only a handful of inputs and omits key concepts (market object shape, preset selection, curve naming, additional_trades semantics). Output return values are covered by the output schema, but the input side is substantially under-specified.

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% across 21 parameters, so the description must compensate, and it does so for market_data_source (a full provenance enum explanation) and for spread/fixings/frequency. But the majority of parameters (market, preset, curve ids, additional_trades, calendar_overrides, schedule_overrides, include_flows, request_id) remain unexplained in both schema and 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?

States a specific verb and resource ('Price a year-on-year inflation swap') plus the underlying endpoint, and cross-references the sibling price_zc_inflation_swap to signal the family it belongs to. It stops short of an explicit differentiator against price_yoy_inflation_cap_floor, so sibling discrimination is only partial.

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

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

No explicit when-to-use vs alternatives compared with price_zc_inflation_swap or price_yoy_inflation_cap_floor. It does give a strong negative rule within the market_data_source text ('If you would have to invent numbers, do not call this tool: ask the user'), which is genuine usage guidance but scoped to one argument rather than the tool as a whole.

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

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

With no annotations, the description carries the behavioral burden and does so fairly well: it states the market must carry the inflation index plus a ZeroInflation curve, that fixings are mandatory because the server has no market-data source, and that the tool mutates the index and reports this in notes. It omits error/failure behavior and any auth or rate-limit context, but for a stateless pricing call this is solid disclosure.

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

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

The purpose is front-loaded and the remainder is organized as a tight Args block with no filler. A few lines are dense but every sentence contributes actionable detail rather than restating the name.

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 needn't be described, and the description covers the genuinely tricky provenance/required-fixings logic well. Yet for an 18-parameter tool the unexplained required curve params (discounting_curve, inflation_curve) and trade-shaping params leave the agent partially unequipped to construct a valid 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, and it does for the high-risk params: market_data_source's four enum values are spelled out, and the fixings shape/semantics are given as an example. However, two REQUIRED params (discounting_curve, inflation_curve) receive no explanation at all, along with market, additional_trades, calendar_overrides, include_flows, and request_id, leaving substantial gaps.

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

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

The description opens with a specific verb+resource ('Price a zero-coupon inflation swap') and even gives the backing endpoint. The 'zero-coupon' qualifier cleanly separates it from sibling tools like price_yoy_inflation_swap without the agent needing to open 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?

The market_data_source paragraph gives explicit when/when-not guidance, including the strong exclusion: 'If you would have to invent numbers, do not call this tool: ask the user for the data.' It also flags fixings as REQUIRED and explains why. It stops short of routing to named alternatives (e.g. the YoY or multi-trade siblings).

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

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

No annotations exist, so the description carries the full load. It usefully discloses that settled params default from the preset, how tenor is counted from issue_date/as_of, and that estimated or recalled data is not accepted, but it says nothing about permissions, side effects, determinism, or failure behavior for a POST pricing call.

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 purpose is front-loaded in one line and the remainder is an efficient Args list with no filler. It is appropriately sized for a 16-parameter tool, though the indented bullets are dense enough to be slightly harder to scan than a tighter format.

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 documented, and the source/guardrail guidance is strong. Still, for a 16-parameter tool with nested objects and 0% schema coverage, leaving required inputs like market and discounting_curve entirely unexplained is a meaningful completeness gap.

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

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

Schema description coverage is 0%, so the description has to compensate, and it does explain market_data_source, preset, maturity_date, issue_date, settlement_days/redemption, and include_details. However, two required parameters (market, discounting_curve) and several others (as_of, request_id, additional_trades, yield_overrides, calendar_overrides, face_amount) get no explanation at all.

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 opening line gives a precise verb+resource ("Price a zero-coupon bond") plus the underlying endpoint, which is enough for an agent to separate it from the many other bond pricing siblings. It stops short of explicitly contrasting itself with price_fixed_rate_bond or price_floating_rate_bond, so it lands at 4 rather than 5.

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 market_data_source enumeration spells out exactly which situations map to which value (pasted, file, engine example, session) and states an explicit exclusion: "If you would have to invent numbers, do not call this tool: ask the user for the data." It gives clear context and a when-not rule, but names no alternative sibling tool, so it misses the top mark.

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

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

No annotations are provided, so the description carries the burden. 'Verbatim from GET /health' usefully signals this is a thin read-only passthrough with no side effects, but it says nothing about the failure/healthy distinction, auth requirements, or latency/rate 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?

A single front-loaded clause with zero filler; the identity of the tool and its data source are in the first few words.

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

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

For a no-parameter liveness probe with an output schema already defining the return shape, the description is nearly sufficient. The only missing piece is how to interpret an unhealthy result or whether any auth/session context is needed.

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

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

The tool takes zero parameters, so there is nothing for the description to clarify beyond the schema; baseline 4 applies.

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

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

States a specific resource and intent: engine liveness, plus the underlying GET /health endpoint. An agent can tell it apart from pricing/build siblings, though there is no explicit contrast drawn with the nearby meta/endpoint tools (quantra_meta, list_endpoints, engine_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?

There is no when-to-use statement, no mention of prerequisites (auth, sessions) and no alternative named. Usage is only inferable from the word 'liveness'.

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

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

With no annotations, the description carries the full burden, and it does disclose one useful trait: the response is the engine body passed through unchanged ("verbatim from GET /meta"). Beyond that it says nothing about idempotency, auth needs, or rate limits, which for a zero-arg read call is a moderate but not severe gap.

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

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

Two short sentences, front-loaded with the identity of the resource and immediately followed by the action-oriented 'call this first' guidance. No filler.

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