Ariadne Nexus Quantitative Engine

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

Annotations already declare readOnlyHint, idempotentHint, and destructiveHint=false, but the description adds practical context the annotations cannot express: the tool is free ($0.00 USD), requires no apiKey or paymentToken, and makes no external network calls or billing mutations. For a fee/billing-adjacent tool, that auth-and-cost disclosure is exactly the information an agent needs to avoid misrouting a paid provisioning flow.

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 verb and output set, then cleanly segmented into 'Use when', 'Do not use when', and 'Behavior' blocks. Every sentence carries routing, scoping, or cost/auth information; no filler.

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

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

With an output schema present, return values need no explanation, and the description covers purpose, routing, prerequisites, and cost. For a zero-required-param, deterministic calculator with full schema coverage, nothing needed to invoke it correctly is missing.

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

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

Schema description coverage is 100% with enum values and defaults fully documented, so the schema carries the parameter burden and baseline 3 applies. The description only gestures at tiers and basis points without adding units, ranges, or interaction semantics beyond the schema; note the param description's example value 'SOVEREIGN_PRIME' does not appear in the enum, but that is a schema-side inconsistency, not a gap the description was obligated to fix.

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 (Calculates) plus four concrete outputs: clearing take-rates in bps and USD, cross-chain bridge tolls, SaaS subscription fees, and net annual clearing cost projections. This is unmistakably distinct from siblings like provision_agent_key or get_cusip_valuation, which the description also names 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?

It provides an explicit 'Use when' clause (estimating monthly/annual clearing fees, bps take-rates, bridge settlement costs before syndicating a vault or choosing a billing tier) and an explicit 'Do not use when' clause that routes to two named alternative tools. Nothing is left to inference.

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

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

Annotations already declare readOnlyHint, idempotentHint, non-destructive and closed-world, so 'read-only, deterministic, zero external side effects' largely restates the structured data. The description does not explain the role of apiKey or paymentToken, which imply an authentication or paid-access gate that matters to an agent before calling. No contradictions, but limited net new behavioral information.

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 computation list is front-loaded, then usage, exclusions and behavior in a fixed order; nothing is redundant. The opening sentence is a long, jargon-dense run-on that could be split for faster scanning, which is the only structural weakness.

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 deterministic compute tool with an output schema and full parameter coverage, the description supplies purpose, audience, exclusions and safety profile, which is nearly everything needed. The remaining gap is access/payment mechanics implied by apiKey and paymentToken, which the description leaves silent.

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

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

Schema coverage is 100%, so the six parameters are already documented; baseline is 3. The description adds framing (eight-variable Beneish model) but never reconciles the '8-variable' claim with only two of those variables (dsri, tata) appearing as defaults, nor explains apiKey/paymentToken semantics beyond the schema text.

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 a concrete set of outputs: Beneish M-Score, Benford Chi-Square, Halliburton II event-study t-statistic, Dodd-Frank bounty projection, and PSLRA recovery model. The regulatory anchor (17 CFR § 240.21F-4(b)(3)) and issuer scope make it distinguishable from any sibling at a glance.

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

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

Explicit 'Use when' clause names the three buyer personas (litigation finance fund, class-action counsel, whistleblower syndicate) and the verification need. The 'Do not use when' clause names two concrete alternatives, get_cusip_valuation and run_portfolio_stress_test, with the condition that selects them.

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

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

Annotations already establish read-only, idempotent, non-destructive, closed-world, but the description adds context structured fields cannot carry: deterministic side-effect-free computation, $0.50 USD per call, and the credential-omitted path that returns an x402/MPP paymentChallenge without charging. That cost/auth behavior is exactly the surplus value a description should provide, and it does not contradict any annotation.

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

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

Front-loaded verb+outputs, then usage, then behavior — a logical order with no filler sentences. The opening enumeration of six analytics quantities is dense and slightly list-heavy, but each clause carries real information, so it stays on the right side of 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?

With 9 optional parameters, full schema coverage, an output schema, and rich annotations, the description covers everything an agent still needs: what is returned in business terms, when to pick this over two named siblings, and the payment/auth flow. Nothing material is left to inference.

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

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

Schema description coverage is 100%, so every parameter (cusip, apiKey, ticker, asset_type, face_value, coupon_rate, market_price, paymentToken, maturity_years) is already documented with units, defaults and examples. The description alludes to par/coupon/maturity/clean price but adds no syntax, ranges or fallback precedence beyond the schema, so the baseline 3 applies.

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

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

The first sentence names a specific verb (computes) and an exhaustive resource envelope (fair market value, YTM, duration, convexity, DV01, jump-diffusion bounds) for a single fixed-income CUSIP. An agent can tell immediately this is single-security analytics, not screening or portfolio work.

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

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

Explicit 'Use when' gives the trigger condition (pricing an individual bond given par, coupon, maturity, clean price) and 'Do not use when' names two concrete alternatives with their own triggers: get_debt_radar for TRACE prints / option collars and run_portfolio_stress_test for multi-position shocks and VaR/CVaR. Routing is unambiguous.

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

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

Annotations already declare readOnlyHint, idempotentHint, and destructiveHint=false, but the description adds material context beyond them: deterministic pricing, the $0.50 USD per-call cost, the apiKey/paymentToken auth path, and the specific behavior that an x402/MPP paymentChallenge is returned without charging when credentials are omitted. That last detail is exactly the kind of non-obvious behavior an agent needs.

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

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

The description is dense and front-loads the highest-value content (what it returns, then when/when-not). Every clause is substantive, though the enumeration of five metric fields plus the solver output makes it long; not a sentence you could delete without losing information.

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

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

An output schema exists, so return values need no explanation in prose. Given annotations, full schema coverage, and the named alternatives, the description covers purpose, selection criteria, cost/auth behavior, and determinism – nothing an agent needs to invoke it correctly is missing.

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

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

Schema description coverage is 100% (each of the 5 params, including defaults and examples, is documented in the schema), so the schema already carries parameter meaning. The description adds the conceptual role of benchmark_ust_yield in collar pricing, but does not add syntax or format detail beyond the schema. Baseline 3 applies.

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

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

The description names a specific verb (retrieves/solves) and two concrete resources (FINRA TRACE dealer execution metrics and a Black-Scholes zero-cost 1-year collar), enumerating the exact output fields. It explicitly distinguishes itself from siblings get_cusip_valuation and run_portfolio_stress_test, so an agent can separate it without opening the schema.

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

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

It provides explicit 'Use when' and 'Do not use when' clauses, naming the alternative tool for each excluded case (get_cusip_valuation for DV01/duration, run_portfolio_stress_test for multi-bond macro stress). Nothing about tool selection is left to inference.

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

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

Annotations already cover read-only/idempotent/destructive status, and the description adds material context beyond them: it is deterministic, costs $1.00 USD per call, and returns an x402/MPP paymentChallenge without charging when credentials are omitted. That payment-and-credential behavior is not derivable from the annotations or schema.

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

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

Front-loaded with the report identity, then cleanly structured as Use-when / Do-not-use-when / Behavior blocks. The prose is dense with domain jargon and repeats the title verbatim, which slightly inflates length, but every clause carries routing or behavioral 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 formatting need not be documented, and the description nonetheless points to markdown_body plus structured telemetry. Combined with the usage exclusions and payment semantics, an agent has everything needed 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 100%, so the baseline is 3, but the description adds real semantics: it clarifies that apiKey and paymentToken are the two credential paths and explains the no-credential fallback behavior. It does not, however, explain include_markdown's effect beyond what the schema already states.

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 (generates) and a concrete resource (Weekly Sovereign Macro-Prudential & Sanctions Monitor), and explicitly names the target desks and indicator set it synthesizes. It also differentiates itself from siblings in the same paragraph rather than leaving the agent to compare 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?

Contains explicit 'Use when:' triggers and 'Do not use when:' exclusions, each routing to a named sibling (screen_ofac_entity for counterparty screening, synthesize_regulatory_docket for comment letters). This is the strongest possible 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?

Annotations already declare readOnlyHint, idempotentHint, destructiveHint=false and openWorldHint=false, and the 'Read-only, deterministic, idempotent ... zero external side effects' sentence largely restates them. The description does add that the certificate is KMS-attested and composes screening plus valuation plus fee calculation, but says nothing new about permissions, what the attestation binds, or how apiKey/paymentToken gating behaves.

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 action and then segmented as 'Use when' / 'Do not use when' / 'Behavior', which is easy to scan. The first sentence is a dense jargon pileup ('OFAC SDN Jaro-Winkler/LEI Merkle proof ... hedonic collateral fair-value attestation') that costs readability, though every clause 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 values need not be explained, and annotations cover the safety profile; the description covers selection, preconditions and the composite computation. The notable omission is that it never says whether the optional apiKey and paymentToken are required to obtain a certificate or what a missing/expired credential does — material context for a fee-bearing oracle.

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

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

Schema coverage is 100%, so the baseline is 3 and the schema does the heavy lifting. The description adds one useful bit of meaning — the HUD-1 Line 1109 fee is '$95 flat or 10 bps on escrow notional', which clarifies transaction_notional_usd — but leaves apiKey, paymentToken and asset_class's role in LTV calibration unelaborated.

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 ('Issues') plus a named artifact ('KMS-attested Statutory Closing Safe-Harbor Certificate') with its three constituent computations spelled out. It explicitly contrasts scope with the sibling screen_ofac_entity, so an agent can route correctly without opening either 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?

Names the exact callers (escrow agent, title company, closing attorney, clearing agent) and the triggering condition ('prior to wire disbursement'). The 'Do not use when' clause names the alternative tool (screen_ofac_entity) and the narrower need it covers.

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

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

Beyond the readOnly/idempotent/non-destructive annotations, it discloses that the call is free ($0.00 USD), does not charge a payment method, create a subscription, or mutate account state, and that billing only occurs on a separate checkout. This is exactly the consequence-level context annotations cannot carry.

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 returned artifacts, which is good, but the delivery is one very dense run-on sentence stacked with parentheticals (Stripe CLI command, URL, license name), making it harder to scan than necessary. It is informative rather than padded, but structure suffers.

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

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

An output schema exists so return values need no explanation, annotations cover the safety profile, and the description supplies the trigger, the exclusion, the behavioral consequences, and the follow-up action. An agent has everything needed 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 100% and the enum values, defaults, prices, and quota figures are already documented per-parameter in the schema. The description adds only generic phrasing about tier comparisons and echoing client details, so the baseline 3 applies.

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

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

States precisely what the tool returns — pricing tiers, quotas, rate limits, Stripe CLI command, and the checkout endpoint for obtaining a Developer API key or FAR 13.2 license. It also names the sibling it is not (calculate_clearing_fee). The only friction is the name/description mismatch: 'provision_agent_key' implies it provisions a key, while the description clarifies it only returns instructions, which the body does resolve.

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

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

Explicit 'Use when:' clause ties invocation to encountering an HTTP 402 paymentChallenge on paid tools, and a 'Do not use when:' clause routes estimating take-rates and bridge tolls to calculate_clearing_fee. Both the trigger and the exclusion with named alternative are stated, nothing inferred.

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

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

Annotations already declare read-only, idempotent, non-destructive, closed-world, but the description goes well beyond them: it discloses the $2.50 per-call cost, the apiKey/paymentToken auth paths, the deterministic simulation characteristic, the fallback to a 3-bond benchmark portfolio when the array is omitted, and the x402/MPP paymentChallenge-without-charging behavior. This is the payment and fallback context an agent needs and cannot get from 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 'Use when / Do not use when / Behavior' structure is well front-loaded and easy to scan, with no filler. The opening sentence is extremely long and packs many analytics into one clause chain, which costs a little readability but not correctness.

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 nested-schema tool of this complexity, the description covers purpose, selection, payment/auth behavior, defaults, and cost, while annotations carry the safety profile and the output schema carries return values. An agent has everything required to decide, authenticate, and invoke correctly.

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

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

Schema description coverage is 100%, so every parameter (apiKey, scenario fields, portfolio positions, paymentToken) is already documented in the schema, which sets the baseline at 3. The description restates the shock dimensions and the benchmark-portfolio default without adding syntax or constraints the schema lacks, so it adds only marginal value here.

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

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

States a specific verb and resource (executes multi-position fixed-income portfolio stress testing under named macro shocks) and enumerates the analytic outputs (DV01, VaR, CVaR, P&L attribution, ZN hedge ratios, collar strikes). It explicitly names the sibling tools it is not — get_cusip_valuation and get_debt_radar — so an agent can disambiguate without opening any schema.

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

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

Provides explicit 'Use when' conditions (rate/credit-spread shocks, portfolio VaR/CVaR, sizing 10Y Treasury futures hedges) paired with 'Do not use when' exclusions that name the correct alternatives for single-CUSIP pricing and TRACE prints. Nothing about tool selection is left to inference.

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

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

Annotations already declare readOnly/idempotent/non-destructive, but the description goes well beyond them: determinism, a $0.50 per-call cost model via apiKey or paymentToken, and the important edge behavior that an omitted credential returns an x402/MPP paymentChallenge without charging. These are exactly the auth and cost traits annotations cannot express.

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: what it does, then when/when-not, then behavioral/pricing notes. Dense but every clause carries information; the heavy parentheticals and layered 'Behavior:' sentence make it slightly long for an agent scanning several tools, but nothing 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?

With an output schema present, the description need not explain return values, and it still flags the verdict and audit proof. Combined with annotations and full schema coverage, an agent has everything needed to decide, invoke, and pay for the 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 100%, so the baseline is 3; the description still adds framing by tying registration_number-style identifiers (LEI/CIK/CRN) to exact registry matching and fuzzy_threshold to Jaro-Winkler phonetic resolution as a combined strategy, which the per-parameter schema text does not state jointly. It does not, however, mention country or the credential parameters.

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

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

States a specific verb and resource ('Screens a corporate entity or individual counterparty against... SDN and consolidated sanctions registries') and even names the matching mechanisms (exact identifier matching, Jaro-Winkler fuzzy resolution) and the output (compliance verdict + Merkle audit proof). It is unmistakable against siblings like get_sovereign_policy_brief or synthesize_regulatory_docket.

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

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

Explicit 'Use when' clause gives the triggering condition (sanctions verification before onboarding or settlement) and the 'Do not use when' clause names two concrete siblings with the scenario that selects each. Nothing is left to inference.

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

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

Although annotations already declare readOnly/idempotent/non-destructive and a closed-world local tool, the description adds value beyond them: per-call pricing ($2.50 via apiKey or paymentToken), and the critical fact that it does NOT transmit or file with regulations.gov, returning only structured text plus a SHA-256 citation hash for human review. That is exactly the kind of side-effect disclosure an agent needs for a 'synthesis' 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 tool's identity, then cleanly partitioned into Use when / Do not use when / Behavior. It is dense with domain jargon and long as a single block, but nearly every clause carries routing or behavioral information rather than 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?

With an output schema present, the description needn't explain return values, and it still covers the essentials: target dockets, auth/payment paths, and the no-external-filing constraint. Nothing an agent needs to call 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 description coverage is 100%, so the schema already documents all six parameters, their defaults, and the agency_id enum. The description restates the docket identifiers and mentions apiKey/paymentToken but adds no syntax or format detail beyond the schema. Baseline 3 applies when the schema does the heavy lifting.

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 (drafts an APA § 553 public comment letter) and a precise domain (Fed/OFR, FinCEN/OFAC, SEC DERA, FSOC dockets). It explicitly distinguishes itself from siblings by naming get_sovereign_policy_brief and screen_ofac_entity, so an agent can disambiguate 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?

Contains explicit 'Use when' and 'Do not use when' clauses, each routing to a named alternative (get_sovereign_policy_brief for the weekly monitor, screen_ofac_entity for sanctions screening). The condition that selects this tool (preparing a statutory comment submission for a specific docket) is unambiguous.

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