Coverage Cat

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

Annotations already declare readOnlyHint=true, idempotentHint=true, and openWorldHint=false, so safety and determinism are covered. The description adds real context by indicating the result spans multiple carriers (a comparison output) and is limited to one driver/vehicle profile. It says nothing about what a 'seed' does to repeatability or about rate limits, so it adds only modest value.

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

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

A single front-loaded sentence with the scope constraint attached; no filler, no repetition of the title. Appropriately sized for a one-line estimator definition.

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

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

For an 11-parameter tool with 0% schema coverage and no output schema, the description leaves a lot open: it never explains which inputs are mandatory, what the deductible parameters do, or what a caller gets back (a list of per-carrier quotes is only implied). Adequate as a one-liner, insufficient as a contract.

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 11 parameters, so the description carries the full burden. 'Single driver and vehicle profile' hints that the params split into driver fields (age, gender, zip, state) and vehicle fields (make, model, year, style), but formats, valid values, required-vs-optional status, and the purpose of seed and the two deductible parameters are entirely undocumented.

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

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

States a specific verb (estimate), resource (monthly auto premiums), and scope (across carriers, single driver and vehicle profile). The 'auto' qualifier implicitly separates it from home_calculator and umbrella_calculator, though it never names an alternative. Clear but not explicitly differentiated from siblings.

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

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

No when-to-use guidance, no prerequisites, and no mention of alternatives among the sibling calculators (home_calculator, umbrella_calculator). The only guidance is the implied 'single driver and vehicle profile' constraint, which is a scope statement rather than usage routing.

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 closed-world behavior, so safety is covered. The description adds that results are 'long-run' costs rather than a single quote, which is meaningful context, but says nothing about the role of the seed parameter, latency, or the shape of 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?

A single front-loaded sentence with no filler or repetition. It is efficient, though its brevity is arguably under-specification rather than true conciseness given the tool's 11-parameter surface.

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

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

For an 11-parameter, no-output-schema, 0%-coverage calculator, one sentence is not enough: an agent cannot tell what inputs are mandatory, what 'current auto profile' resolves to, or what the comparison returns. The readOnly annotation covers safety only, leaving substantive 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?

With 11 parameters and 0% schema description coverage, the description must carry the parameter burden and it does not. It gestures at the two deductible parameters via 'collision and comprehensive coverage costs' but leaves state, zip, age, gender, seed, make, model, year and style entirely unexplained.

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 action (compare) and resource (collision and comprehensive coverage costs) scoped to the current auto profile, which separates it from the home and umbrella calculators in the sibling list. However, it never explicitly contrasts itself with auto_estimates, so the agent must infer the distinction.

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 phrase 'for the current auto profile' hints at a precondition but the description never states when to choose this tool over auto_estimates or other calculators, nor any exclusions. It is implied usage only, with no 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=true, idempotentHint=true, openWorldHint=false, so the safety profile is covered. The description adds genuinely useful behavior beyond that: session-state preservation requirements, the token fallback path, that drafts are not resumable by email alone, and the consumer-operated subset constraint. Some mutating language ("patch the canonical umbrella_details.* count field") is ambiguous about whether this tool writes, but it is generally attributed to consumer_intake_patch.

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 sprawling paragraph mixes this tool's behavior with policy that belongs to consumer_intake_patch (patching counts), homeowners vs umbrella turn rules, birthday normalization, and estimated-value formatting. The purpose is front-loaded, but the bulk is dense, hard to scan, and only partially relevant to invoking this 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 return values need not be described, and annotations cover safety. But the description is bloated with tangential policy while still leaving the boundary between this tool and consumer_intake_patch ambiguous, and it never clarifies what the follow-up/status result actually contains. Adequate but muddled for the complexity involved.

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

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

Schema coverage is only 50% (uid has no schema description), so the description must compensate, and it largely does: it explains that uid alone suffices when the host preserves the session, and that intake_access_token is the fallback reusing the latest token without showing it to the shopper. What 'uid' actually is (an issued draft identifier) is only implied, so it is not fully self-contained.

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 gives a workable verb+resource ("Continue a consumer-prefill homeowners or umbrella handoff in chat"), and it does name sibling tools (consumer_intake_patch, delegated tools) to differentiate. However, the name/title ("intake_issues", "follow-up status") imply a read/reporting tool while the body describes continuing a handoff and staging reviews, leaving the core purpose fuzzy. An agent can guess the intent but not cleanly state what this tool returns or does.

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

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

It gives concrete when-to-use and when-not guidance: prefer the preserved hidden MCP session with only uid, retry with the latest intake_access_token rather than falling back to raw HTTP or asking the shopper for credentials, and stay in the default consumer MCP subset instead of jumping to delegated tools when no operator bearer key is present. It also names alternatives (raw HTTP, delegated tools, consumer_intake_patch). It stops short of a crisp decision rule for every case.

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

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

Annotations declare readOnlyHint=false, openWorldHint=false, idempotentHint=true, and the description adds genuine context beyond them: hidden session preservation, a bearer-token fallback, 24-hour idempotent replay, and submission gating via confirm_submission. Much of the remaining text is shopper-facing presentation guidance rather than tool behavior, 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?

The description is a single sprawling block that mixes session mechanics, key naming rules, formatting directives, and retry policy. It is not front-loaded by topic and is difficult to parse; the useful core sentence is immediately buried by a long tail of procedural instruction.

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 nested-schema tool with an output schema and idempotency behavior, the description covers session handling, submission gating, field conventions, and post-submit follow-ups. Return values are handled by the output schema, so the main coverage gaps are structural rather than missing concepts.

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 88%, so the baseline is 3, but the description adds real meaning: canonical umbrella key names (`address.street`, `net_worth_numeric`, `umbrella_details.motorized_vehicle_count`), keys to avoid (`street`, `drivers_license_number`, `net_worth`), birthday normalization, and how to translate raw limits into the banded enum. This exceeds what the schema conveys.

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

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

The opening sentence gives a specific verb and resource: 'Patch a consumer-prefill homeowners or umbrella handoff in chat.' It also references sibling concepts (`consumer_intake_issues`, delegated tools) and the intake flow, but does not cleanly position itself against the prefill/select/bind siblings; the core purpose is clear though surrounded by procedural noise.

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 usage and exclusions are present throughout: use `intake` for homeowners context-backed answers, retry with `intake_access_token` if the host cannot preserve session state, do not drop to raw HTTP or delegated tools when no operator bearer is present, and set `confirm_submission` only on the final review turn. Multiple when/when-not conditions and alternatives are named.

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, and closed-world behavior, so the safety profile is covered. The description adds useful context beyond that: it discloses the return format (markdown, JSON, or YAML body) and the source ('the default consumer MCP'), which is meaningful given there is no output 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?

A single front-loaded sentence that states the action, the identifier, and the return format without waste. The trailing 'from the default consumer MCP' is slightly opaque but does add provenance context.

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 no output schema, the description carries the burden of describing return values, and it does so by enumerating markdown/JSON/YAML. Combined with full schema coverage on the single parameter, an agent has enough to invoke it correctly; only explicit alternatives are 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% and there is only one parameter, so the baseline is 3. The description adds no syntax or format detail about the URI beyond what the schema already states, so it does not exceed the baseline.

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 provides a specific verb+resource pair: 'Read a specific Coverage Cat docs resource by URI.' The phrase 'a specific ... by URI' distinguishes it from the list/search siblings docs_list_topics and docs_search, though those siblings are not explicitly named in the description 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?

Usage is implied: an agent retrieves an individual resource once it has a URI. There is no explicit when-to-use or when-not-to-use statement, and no alternative is named. The schema does hint that the URI comes from docs_list_topics or docs_search, which partially compensates.

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 closed-world behavior, so safety is covered. The description adds the scope note that results come from the same default consumer MCP connection, but says nothing about the limit/pagination behavior implied by the schema, so it adds only modest value.

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

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

A single front-loaded sentence with no filler; the resource enumeration is dense but earns its place. It is appropriately sized, though slightly under-informative rather than over-wordy.

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 no output schema and completely undocumented parameters, the description should explain what is returned (topics vs skills vs artifacts) and how limit/category shape the result. It leaves the agent unable to predict result shape or filtering behavior.

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 parameter (limit, category) is explained in the description. The phrase 'runtime skills' loosely hints at the 'skills' enum value, but there is no mention of the category filter or the 1-25 limit, so the description fails to 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?

States a clear verb (List) and a concrete resource set (documentation topics, runtime skills, machine-readable artifacts), which is more specific than the title. It does not explicitly distinguish itself from siblings docs_search and docs_get_resource, so it falls short of 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?

There is no when-to-use or when-not-to-use guidance, and no alternative tool is named despite docs_search and docs_get_resource sitting in the same family. The only contextual clue is 'same default consumer MCP connection', which hints at scope but does not tell the agent when to pick this over search.

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

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

Annotations already declare readOnlyHint=true, idempotentHint=true, and openWorldHint=false, so the safety profile is covered without description help. The description adds that this is a search operation and that no extra server is needed, but says nothing about result format, ranking, or how 'limit' bounds results.

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 sentence that front-loads the verb and resource and wastes no words. It is slightly dense with the enumerated doc categories, but every clause contributes to scoping the 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?

For a simple read-only search tool with annotations covering safety and no output schema, the description adequately conveys scope and the built-in-vs-optional-server context. It remains incomplete regarding the undocumented 'limit' parameter and any hint about result count or ordering.

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

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

Schema coverage is only 50%: 'query' is documented in the schema, but 'limit' (integer, min 1, max 10) has no description anywhere. The description mentions no parameters at all, so it does not compensate for the undocumented limit or clarify pagination/capping behavior.

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 ('Search') and resource ('docs') and enumerates the doc categories covered (quickstart, auth, sandbox, OpenAPI, runtime skills). It does not explicitly contrast itself with the closely named siblings docs_get_resource and docs_list_topics, so differentiation is left to inference.

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 phrase 'without installing the optional docs-only MCP server' implies when this tool is preferable (built-in alternative to an optional server), giving useful context. However, it never states when to use docs_search versus the sibling docs_get_resource or docs_list_topics, so usage is only 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?

Annotations already declare readOnlyHint, idempotentHint and openWorldHint=false, so safety and determinism are covered structurally. The description adds one useful behavioral fact beyond that: the output is a comparative recommendation (file vs. pay out of pocket) rather than raw numbers. It still says nothing about whether required inputs like gender/age affect the estimate or how the comparison is derived.

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 sentence with no filler. It is efficient, though its brevity is partly under-specification rather than disciplined concision.

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 12-parameter, 5-required tool with zero schema coverage, no output schema, and no parameter documentation anywhere, one sentence cannot be sufficient. Nothing explains the inputs, the calculation basis, or the shape of the result.

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 12 parameters, and the description names none of them. Five required fields (state, zip, age, gender, repair_estimate) are undocumented in both the schema and the description, so an agent has no idea why gender or age are needed or what formats are expected.

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 outcome: estimating whether filing an auto claim beats paying out of pocket. It is far clearer than a bare 'claim calculator,' but it never distinguishes itself from the sibling auto_estimates or collision_and_comprehensive_coverage, so an agent must guess which estimator applies.

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 the sibling tools an agent might pick instead (auto_estimates, collision_and_comprehensive_coverage). The agent is left to infer the scenario entirely from the one-line purpose.

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

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

Annotations declare readOnlyHint, openWorldHint=false, and idempotentHint, so the safety profile is already covered. The description adds the California/ZIP scoping constraint, which is useful, but doesn't mention rate limits, precision of estimates, or that results are non-binding. With annotations carrying the behavioral load, a 3 is appropriate.

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, well-formed sentence that front-loads the action and resource with zero waste. 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?

For a read-only calculator with no output schema, the description is adequate but leaves gaps: it doesn't explain what the estimate returns, whether it's a range or point value, or any limitations. The agent knows roughly what the tool does but not the shape or reliability of its output.

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 67%, so zip and risk_factors are documented in the schema, while home_sqft lacks a description beyond its bounds. The description names 'ZIP code, square footage, and risk factors' but adds no syntax or format detail beyond what the schema already provides. Baseline 3 fits.

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 ('Estimate') and resource ('annual home insurance pricing') plus the scope ('California property'). It distinguishes itself from umbrella_calculator and auto_estimates by domain, but does not explicitly name 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?

No guidance on when to use this tool versus umbrella_calculator or auto_estimates, nor on prerequisites or subsequent steps. The agent must infer usage context 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?

Annotations already declare readOnlyHint=true, idempotentHint=true, and openWorldHint=false, so the safety profile is covered. The description adds the coverage constraint ('supported states') and the licensing qualifier, which is useful, but says nothing about result format, pagination, or behavior on unsupported ZIPs.

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 sentence with the verb, resource, and filters in order of importance. No filler and nothing repeated from the title.

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 no output schema, the description should say more about what a match returns and what happens outside supported states. It is adequate for a simple read-only lookup but leaves the coverage caveat and result shape unstated.

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

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

Schema coverage is 67%: zip and lines carry descriptions while limit is only bounded by min/max with no explanation of its meaning. The description maps to zip and line type but adds no format or semantic detail beyond the schema, so baseline 3 is appropriate.

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

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

States a specific verb (find), resource (licensed homeowners agents), and scope (supported states) plus the two filtering dimensions. The resource is unique among the siblings, which are all consumer bind/policy/service tools or calculators, so an agent can distinguish it, though no sibling is named 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?

No when-to-use guidance, no prerequisites, and no statement about what to do when a ZIP falls outside the supported states. The phrase 'supported states' hints at a constraint but never explains it or points to an alternative tool.

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

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

Annotations already declare non-readOnly, idempotent, and closed-world, and the schema documents the 24h idempotency replay. The description adds genuinely new behavioral context: payment/signing cannot happen in chat and is emailed to the customer's registered channel, and session-preservation caveats are disclosed. It stops short of auth/error or rate-limit detail, but the added context is solid.

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 critical precondition is front-loaded in the first clause, and most sentences carry actionable guidance (session fallback, credential handling, payment channel). Some phrasing is convoluted ('Stay on the same consumer-operated MCP subset'), but there is little outright waste.

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

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

With an output schema present, return values need not be explained, and the description covers the key concerns for a bind mutation: sequencing, session vs. token fallback, confirmation inputs, and payment handling. Missing only auth-failure/error handling detail, which keeps it short of complete.

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

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

Schema coverage is only 40%, so the description must carry weight on uid, preview_token, and bind_confirmed. It explains that a preserved host usually needs only uid, and that preview_token is sent together with bind_confirmed: true after confirming previewed terms and the email channel. It adds real meaning beyond the schema, though it never clarifies uid format or preview_token provenance.

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 action (continue the homeowners bind follow-up) and situates it precisely in the workflow: it only runs after homeowners_consumer_select returns ready_to_finalize. This clearly separates it from prefill/select siblings. The verb phrasing is slightly process-oriented ('bind follow-up') rather than a crisp 'binds the policy,' but the intent 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?

It states the exact precondition (only after select returns ready_to_finalize), the canonical path (preserved MCP shopper session, only uid needed), and an explicit alternative for hosts that cannot preserve session state (retry with the latest intake_access_token). It also steers away from raw HTTP and from asking the shopper for credentials.

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 readOnly/idempotent/closed-world, and the description adds substantive behavior: it returns bound OR cancelled policies, documents, and request history, plus the session-preservation and token-fallback auth path. It stops short of describing pagination or response shape, but adds real context beyond the annotations.

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

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

Purpose is front-loaded, but the middle section is repetitive and meandering ('retry this same MCP follow-up tool with the latest intake_access_token... instead of dropping to raw HTTP'), restating the same follow-up mechanism twice and padding an otherwise simple read 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 return values need not be explained; the description covers trigger conditions, the read-only nature, scope of returned data, and the token fallback. It is complete enough to invoke correctly, with only uid semantics left 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?

With 50% schema coverage, the description carries part of the burden: it explains that a preserved host 'usually only needs uid' and details the intake_access_token fallback origin and secrecy rule, which enriches the schema's own token description. The uid field itself is never explained, which is the remaining 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: 'Read the current bound or cancelled homeowners policy record, policy documents, and any existing cancellation, refund, or support request history.' That clearly separates it from mutation siblings like homeowners_consumer_bind or homeowners_consumer_service, though it doesn't name those siblings 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 trigger conditions: 'Use this read-only tool after Coverage Cat reports a policy on file, or after a service request is opened,' and warns against 'switching to delegated tools.' It does not distinguish this from umbrella_consumer_policy or other read siblings, but the when-to-use context is clear.

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

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

Annotations only give readOnlyHint=false, openWorldHint=false, idempotentHint=true. The description adds substantial undisclosed behavior: 48-hour quote/bind lag requiring continued polling, session preservation semantics, the consumer_intake_issues/reply_pending follow-up loop, the prohibition on collecting payment in chat, email-inbox-only link delivery, and review-turn presentation rules. This is far beyond what the annotations convey.

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

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

The purpose and entry condition are front-loaded, but the body is a dense wall of prose mixing behavioral rules with very granular formatting directives (the `*` / `* = estimated` placement). Most sentences carry real rules, yet the volume and some repetition reduce readability for an agent skimming for the call contract.

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 multi-turn prefill/handoff flow, the description covers entry conditions, data gathering, follow-up handling, retry semantics, payment constraints, and presentation rules. An output schema exists, so return values need not be explained, and 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 coverage is 50%; idempotency_key and credit_consent_pending are already documented in the schema, while the two nested objects (intake, field_estimates) are undocumented there. The description partially compensates by listing the facts to gather into intake (name, email, address, coverage type, DOB, marital status, occupancy) and by referencing estimated values tied to field_estimates, so it adds meaningful but incomplete parameter meaning.

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

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

The first sentence names a specific verb+resource (the homeowners MCP entry point for shopping/comparing/buying homeowners insurance) and a distinguishing condition (no operator bearer token present). It is immediately separable from siblings such as homeowners_consumer_bind, homeowners_consumer_select, and umbrella_consumer_prefill.

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 exactly when to enter this tool (cold-start shopper wanting Coverage Cat to shop/compare/buy, no operator token), what to ask for on cold start, and how to route within the flow (prefill → review → quote polling → select → bind → post-bind). It also names the fallback path (retry with latest intake_access_token) and forbids the wrong alternatives (raw HTTP, asking for credentials).

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

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

Annotations declare it is a mutation (readOnlyHint=false) that is idempotent, and the description adds substantial context beyond that: it stages an offer without collecting payment, does not begin carrier bind follow-up, depends on preserved MCP session state or a bearer fallback, and requires the token never be shown to the shopper. These are meaningful behavioral constraints for a mutation tool. It does not describe error or timeout behavior directly, though the idempotency_key schema covers replay.

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, which is good, but the remaining prose is long and convoluted ('a preserved host usually only needs uid,' 'Coverage Cat prefers to keep follow-up authorization in the hidden MCP shopper session'). Several clauses earn their place (payment and bind exclusions, session fallback), yet the phrasing is inefficient and would benefit from tighter structure.

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, and the annotations carry the safety profile. The description fills the remaining gaps an agent needs: prerequisites (session state or fallback token), scope limits (no payment, no bind yet), and the intended next step. It is largely complete for this step of the flow, with only minor omissions around failure handling.

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

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

With only 40% schema description coverage, the description usefully compensates: it explains uid ('a preserved host usually only needs uid'), that intake_access_token is an optional fallback taken from the previous successful response, and that selection_token is the value returned by the prior step. It does not explain selection_confirmed (const true) or idempotency_key, though the latter is well-documented in the schema itself.

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

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

The description states a concrete action (continue the homeowners flow after quotes are ready and stage the exact selected offer for a final bind approval in chat), which is a clear verb-plus-outcome for the select step. It distinguishes itself from the bind step by stating it 'does not start carrier bind follow-up yet,' differentiating it from homeowners_consumer_bind and umbrella_consumer_select. The core purpose is present but somewhat buried under session-state guidance, so it is clear rather than maximally sharp.

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 real when-to-use context: this is the follow-up after prefill/quotes are ready, and it names the fallback path (retry with the latest intake_access_token) plus the anti-patterns to avoid (raw HTTP, asking the shopper for credentials). It implies the bind step follows but never names homeowners_consumer_bind explicitly, so routing to the next sibling 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?

Goes well beyond the annotations: it explains the preview/confirm two-step, the 24-hour idempotency replay window, rejection of a changed payload under the same key, and the bearer-token fallback for hosts that cannot preserve MCP session state. The annotations (readOnlyHint=false, idempotentHint=true) confirm this is a mutating, idempotent call, and the description enriches that with concrete operational details rather than contradicting it.

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 most sentences carry actionable behavioral guidance, but the session-state and token-fallback prose is wordy and slightly repetitive (two separate sentences on preserving MCP session state). It is longer than necessary for a tool whose schema already documents the 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 an 8-parameter mutating tool with a conditional required field and an output schema, the description covers the full lifecycle: preview, confirmation, idempotent retry, auth fallback, and the prohibition on declaring the request complete prematurely. With an output schema present, it correctly does not need to describe return values.

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

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

Schema description coverage is 100%, so the baseline is 3 and the schema already documents every parameter including confirm_request, idempotency_key, intake_access_token, and the conditional requested_effective_date. The description adds only marginal semantics, mainly that uid is usually sufficient when the host preserves session state, which the schema does not state.

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 pair ('preview or open') and a concrete resource set ('a cancellation, refund, or support request for a consumer homeowners policy'), which clearly separates it from the read-only homeowners_consumer_policy and the umbrella_consumer_service sibling. An agent can identify the tool's domain and action 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?

Explicitly sequences the workflow: preview the consequences first, then send confirm_request: true only after shopper approval. It also routes the agent on retry behavior ('retry this same MCP follow-up tool with the latest intake_access_token ... instead of dropping to raw HTTP') and forbids premature completion claims, covering both when and how-not to use 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?

Annotations already declare readOnlyHint, idempotentHint and openWorldHint=false, so the safety profile is covered. The description adds meaningful context beyond that: output is a directional band, not a bindable quote, and this tool never initiates shopping or purchase. It does not mention return shape beyond 'pricing bands,' which is acceptable given no output 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?

Two tightly written sentences with no filler, and the research-only scoping is front-loaded before the exclusion clause. Every clause 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?

Without an output schema, the description should clarify return semantics and the input dimensions, but with 11 mostly undocumented parameters and a missing 'coverage limit' input, the picture is incomplete. It does correctly signal that results are estimated bands rather than quotes.

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

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

With 11 parameters and only ~9% schema description coverage, the description carries most of the burden but only gestures at 'household risk factors.' It never explains the individual risk inputs (jet_skis, drivers_under_22, moving_violations, etc.) or their units, and it references a 'coverage limit' dimension that has no corresponding parameter 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 and resource ('Research-only estimate of annual personal umbrella pricing bands') plus the dimensions it varies over (coverage limit, household risk factors). It is clearly distinguishable from the umbrella_consumer_* siblings, which shop/bind/pay rather than estimate.

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 gives both the when ('use this for directional pricing') and the when-not ('not when the shopper wants Coverage Cat to shop for or buy umbrella insurance'), functionally routing the agent away from the consumer flow tools. Nothing is left to inference about the intended 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?

Annotations already declare readOnlyHint=false, openWorldHint=false, and idempotentHint=true, so the bar is lower, yet the description adds real context: the hidden shopper-session dependency, the intake_access_token bearer fallback for hosts that cannot preserve session state, and delivery timing (~5-10 minutes for secure checkout). It does not quantify size limits or describe 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?

Purpose is front-loaded, but the paragraph then sprawls through session-preservation rationale, retry guidance, batch preference, and checkout timing in one run-on block. Several clauses (the Coverage Cat narrative, checkout timing) could be trimmed or condensed without losing actionable content.

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

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

An output schema exists, so return values need not be explained, and annotations cover the safety/idempotency profile. The description supplies the flow phase, prerequisites, mode choice, and auth fallback needed to call it correctly, leaving only minor gaps like payload size limits.

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 57%, so some compensation is warranted. The description explains that uid alone may suffice when the session is preserved, that attachments is the preferred single-turn batch mode, and how intake_access_token is reused across retries. These add usage meaning beyond the schema's per-field text, though the base64 mechanics are restated from the schema rather than extended.

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 ('Upload declarations or auto declarations') and pins it to a precise flow stage ('consumer-prefill umbrella post-choose flow'). It is readily distinguishable from siblings like umbrella_consumer_prefill, umbrella_consumer_select, and umbrella_consumer_bind 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?

Gives explicit preconditions ('Use only after selection and only when Coverage Cat says documents are needed') and names concrete alternatives: prefer a single batch attach call when both files exist, and use the REST binary fallback when raw bytes/disk files are available. It also rules out dropping to raw HTTP or asking the shopper for credentials. This is near-complete 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=false, openWorldHint=false, and idempotentHint=true, and the description is consistent with that write/idempotent profile. It adds genuinely new context beyond the annotations: the hidden MCP shopper session dependency, the 24-hour token reuse path, and the instruction to keep the flow inside the consumer-operated MCP subset. It stops short of describing permission scope 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?

The gating condition is front-loaded, which is good, but the body is padded with reflective phrasing ('Coverage Cat prefers to keep follow-up authorization...') and an oddly specific Markel/vehicle-details aside that sits far from the calling decision. Information density is uneven rather than wasteful, but several clauses could be tightened.

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, and the description covers the session/auth model, the correct intake contents, and the retry contract. The main remaining gap is that the nested `intake` object's expected fields are never enumerated, leaving the agent dependent on the select response to know what to send.

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

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

Schema coverage is only 50% (uid and the nested intake object are undocumented in the schema), and the description compensates by explaining that a preserved host 'usually only needs uid' and that only the current bind-stage fields should go inside `intake`. The idempotency_key and intake_access_token semantics overlap with their schema descriptions, but the uid/intake guidance is real added 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?

The description states a specific verb+resource (continue the umbrella consumer bind follow-up) and pins it to a precise trigger: 'only after select returns needs_more_info_to_bind or ready_to_finalize.' That is clear enough for an agent to know this is a bind-stage continuation, though it never explicitly contrasts itself with its sibling homeowners_consumer_bind, relying on the name prefix for that distinction.

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 an explicit entry condition (select returned needs_more_info_to_bind or ready_to_finalize), states what to do when the host cannot preserve session state (retry with the latest intake_access_token), and names what NOT to do (drop to raw HTTP, ask the shopper for credentials). When-to-use, when-not, and the fallback path are all 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?

Annotations only declare readOnlyHint=false, openWorldHint=false, and idempotentHint=true, but the description adds substantial context beyond that: session-state preservation requirements, the token-based retry path, the recommendation not to drop to raw HTTP, the prohibition on collecting card details via chat, and the two-phase call sequence. This is rich operational disclosure that the annotations alone do not convey.

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

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

The purpose is front-loaded, but the body is a dense run-on that packs multiple distinct instructions into single sentences (session preservation, retry token, UI render confirmation, fallback). Most content earns its place, yet the lack of structure makes it harder to parse than necessary.

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 multi-phase, mutating payment tool this is thorough: it covers prerequisites, both call modes, UI-render confirmation, retry behavior, and the fallback path. An output schema exists, so return-value detail is not needed, and the description does not leave a functional 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 100% and each parameter is already well documented, including the either/or constraint between payment_collection_requested and the setup_intent_id/payment_method_id pair. The description adds sequencing ('After successful Stripe setup, call this same tool again with setup_intent_id and payment_method_id') but largely reinforces what the schema already states, so it sits at the baseline 3.

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

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

The description opens with a specific verb+resource+scope: 'Prepare secure Stripe payment collection or submit the resulting payment method during the consumer-prefill umbrella post-choose flow.' This clearly distinguishes it from siblings like umbrella_consumer_attach, umbrella_consumer_bind, and umbrella_consumer_select, and an agent can tell what the tool does 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 states explicit preconditions ('Use this only after Coverage Cat says payment_needed'), ordering ('First call it with payment_collection_requested: true'), exclusions ('do not send the shopper straight to payment_url', 'do not request card details through conversational text'), and fallback routing ('if UI support is unknown or unsupported... share payment_url with the specific fallback reason'). 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=true, idempotentHint=true, and openWorldHint=false, so the description's added value is auth/session behavior. It discloses that a preserved host usually only needs uid, that intake_access_token is a fallback when session state cannot be preserved, and that the token should not be shown to the shopper. This is useful context beyond the annotations, though it does not cover token expiry or other edge cases.

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

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

The description is front-loaded with the core read purpose, then provides usage and auth fallback guidance. However, the session/token explanation is verbose and repetitive for a two-parameter read tool, and phrases like "hidden MCP shopper session" add narrative weight without increasing call accuracy.

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?

Because an output schema exists, return values need not be explained. The description covers purpose, when to use it, read-only safety, and auth/session fallback. It is largely complete for this tool, though it could better specify the uid parameter's meaning.

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 50%: uid has no schema description, while intake_access_token is documented in the schema. The description adds that uid is usually sufficient when the MCP session is preserved and explains the token fallback context, but it never defines what uid is or its format, so it only partially 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?

The description states a specific verb and resource: "Read the current bound or cancelled umbrella policy record, policy documents, and any existing cancellation, refund, or support request history." It clearly scopes the read to policy facts and related history, which distinguishes it from action-oriented siblings like umbrella_consumer_bind and umbrella_consumer_service.

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

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

It gives explicit timing and context: "Use this read-only tool after Coverage Cat reports a policy on file, or after a service request is opened, to show policy facts without switching to delegated tools." It also explains the session/token fallback, but it does not explicitly name when-not-to-use scenarios or alternative sibling tools by name.

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 only three coarse annotations, the description still carries real behavioral weight: sandbox is limited to the first call, session state is preserved server-side so a host usually needs only uid, intake_access_token is the fallback credential, drafts are not resumable by email, and the application is explicitly not yet submitted. It does not, however, describe error modes or how repeated prefill calls merge into existing intake.

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, but the body runs long and blends tool-selection guidance with shopper-facing output formatting rules (bulleted summaries, asterisk-marked estimates) and duplicates the canonical-key list already present in the intake schema description. Some of that is necessary orchestration detail, but the density and repetition cost readability.

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

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

For a complex, multi-stage orchestration entry point with a nested intake object and an output schema, the description covers sequencing across the whole consumer tool set, sandbox behavior, credential handoff, and draft continuation. The remaining gap is what a successful response contains and how failures or re-calls behave, which the output schema only partly compensates for.

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

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

Schema coverage is 100%, so the baseline is 3, but the description adds meaning beyond the schema: it names legacy keys to avoid (top-level street/city/state/zip, drivers_license_state, drivers_license_number, net_worth, desired_umbrella_liability_limit) and cautions against sending vehicles rows early or field_estimates unless paths match. Those are field-validity rules not restated 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?

The opening sentence gives a specific resource and role (umbrella consumer prefill as the preferred entry point for umbrella shopping) and pins the condition that selects it (no operator bearer token present). It is distinguishable from siblings like homeowners_consumer_prefill, the umbrella_consumer_* post-prefill tools, and delegated tools by name.

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

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

It states when to call (cold start, before any questionnaire), how to behave (assemble the fullest justifiable estimate, keep the shopper out of step-by-step flow), and explicit when-nots (do not switch to delegated tools for checkout/aftercare, do not use raw HTTP, do not resume drafts on email alone, do not drop to the operator path). Alternatives and exclusions are named rather than 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?

Annotations already declare readOnlyHint=false and idempotentHint=true, so safety/idempotency is partly covered, but the description adds real value: the soft-credit-check consent requirement, the session-state preservation assumption and the intake_access_token bearer fallback, and the credit_consent_required retry loop. It does not restate the 24h replay cache beyond what the schema's idempotency_key description already says.

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?

One dense paragraph of long conditional chains rather than a scannable list, and the core action is buried behind narrative framing about Coverage Cat's session behavior. Nearly every sentence carries some operational information, so little is pure filler, but the front-loading and readability are poor for a definition this size.

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; the description instead covers the happy path, the session-loss fallback, the consent-requirement branch, and the combined consent+bind retry. That is close to complete for a complex stateful selection tool, with only the unmentioned um_uim_election handling and sibling contrast 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?

With 63% schema description coverage across 8 params, the description usefully explains that uid is usually sufficient when host session state survives, that intake carries bind-stage answers, that credit_consent must be real-user consent collected here, and that intake_access_token is a fallback bearer. It leaves um_uim_election and selection_confirmed entirely to the schema, so it does not 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?

The description states a specific action in the flow — continuing the consumer-prefill umbrella flow to select an offer after quotes are ready — and the use of selection_token/selection_confirmed makes the 'select' verb concrete. It distinguishes itself from the adjacent prefill/bind/payment siblings by flow position, though it never names those siblings 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?

Strong conditional guidance: it states when to use this tool (after quotes are ready, on the same consumer-operated MCP subset), what NOT to fall back to (raw HTTP, asking the shopper for credentials, delegated tools), and how to retry when host session state is lost. The absence of an explicit contrast against the closest siblings (e.g. umbrella_consumer_bind/attach) keeps it from a 5.

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

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

Annotations cover the safety profile (readOnlyHint=false, openWorldHint=false, idempotentHint=true), and the description adds non-obvious behavior: the preview/confirm two-step, session-state persistence across follow-up calls, the token fallback path, and the rule not to call an issue 'completed' before Coverage Cat confirms. Nothing here contradicts the annotations; the idempotency claim is consistent with idempotentHint=true.

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

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

Purpose and the preview/confirm rule are front-loaded, and each sentence carries operational content. It is still a dense five-sentence block, and 'Stay on the same consumer-operated MCP subset after bind' is the least concrete sentence and could be tightened without losing meaning.

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 describe returns, and it still covers the prerequisites an agent must know: required gating on shopper approval, session/token handling, retry behavior, and the warning against prematurely reporting a completed outcome. Nothing essential 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 coverage is 100%, so the baseline is 3, but the description adds real meaning on top: it explains why uid alone usually suffices, how intake_access_token is used as a fallback (and must not be shown to the shopper), and it reinforces the confirm_request preview-then-commit semantics. It adds less for reason/details/requested_effective_date, which the schema already documents.

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 gives a concrete verb pair and resource: 'Preview or open a cancellation, refund, or support request for a consumer umbrella policy.' This is a post-purchase service tool, which separates it from the bind/select/prefill/payment siblings without needing to name them 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 states an explicit gating rule ('Preview the consequences first, then send confirm_request: true only after the shopper approves opening the request') and an explicit fallback for hosts that lose session state, routing the agent away from raw HTTP or asking the shopper for credentials. When-to-use and when-not-to-advance are both spelled out.

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