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

With no annotations, the description carries the full behavioral burden and delivers: it discloses exact thresholds (30%+ above high estimate), matching logic for vagueness, timeline/change-order risk, deterministic verdict categories, and even why arguments are optional. No side effects are implied but 'evaluate' plus this detail is sufficiently transparent.

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 about four sentences and is front-loaded with the core purpose, followed by precise criteria, verdict semantics, and a useful optionality note. Every sentence adds 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?

Given no output schema and no annotations, the description explains the verdict values, risk conditions, and missing-input behavior well. It is only slightly incomplete because it does not describe the expected bid/estimate structures or the exact payload shape of the assessment 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?

The schema provides only names/defaults, so the description must add meaning. It clarifies that 'bid' is a contractor bid and 'estimate' is an internal estimate with line items and a high estimate. However, it never specifies the expected object shapes or property names an agent needs to construct valid arguments.

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 verb 'Evaluate' plus resource 'a contractor bid against the internal estimate' states a specific action, and the outcome categories (inflated/vague/timeline risks, reasonable/concerns/reject) make it distinct from sibling tools. No other sibling name is needed to understand what this tool is for.

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 use case is implied clearly: use this when you have a contractor bid and an internal estimate to compare. However, there is no explicit when-not-to-use guidance or mention of alternative tools like renovation_estimate or generate_sow, so an agent must infer the boundary.

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

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

The description goes beyond typical expectations by explaining the behavior for missing and unknown categories, including the unusual design choice of declaring the parameter optional to ensure errors are returned as payloads rather than validation crashes. This is significant behavioral context that helps an agent understand error handling.

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

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

The description is concise and well-structured. It front-loads the core purpose in the first sentence, then provides essential behavioral details in a clear parenthetical note. Every sentence adds value, and there is no wasted text.

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 one-parameter tool with no output schema or annotations, the description covers the essential usage and error handling. It doesn't describe the return format or list valid categories, but those might be accessible through sibling tools like list_categories, and the closed vocabulary hint is sufficient for an agent to know how to proceed.

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

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

With 0% schema coverage, the description must compensate, and it does: it explains that category is a closed vocabulary and describes the error behaviors for missing and unknown values. It could mention that category is a string, but the schema already shows that, and the description adds meaningful semantics about the allowed values (closed set) and error handling.

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

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

The description states a clear verb and resource: 'Find all components in one category', and clarifies that the category is a closed vocabulary. It distinguishes itself from sibling tools by focusing on category-based retrieval rather than search or listing all components, though it doesn't name a specific sibling.

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

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

The description clearly indicates when to use this tool: when you need components for a specific category, with a closed vocabulary. It doesn't explicitly name alternatives or exclusions, but the closed vocabulary hint and the semantic distinction from search_components and list_components provide adequate guidance.

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

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

The description adds useful behavioral notes: generation is deterministic and core arguments are optional so missing-input refusals arrive as payloads instead of validation crashes. However, with no annotations, it does not disclose side effects, error behavior, or limitations beyond that single validation note.

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-loaded: the first sentence states the artifact, the second expands on contents, and the third explains a non-obvious validation behavior. The parenthetical is slightly implementation-heavy but contributes useful 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?

Given 7 optional parameters, no output schema, and no annotations, an agent needs more guidance on what inputs to supply and how missing data is handled. The description defines the output well but leaves the input contract largely implicit.

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

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

Schema description coverage is 0%, so the description must compensate by explaining parameters. It mentions output content and 'core arguments' but never explains what unit_id, finish_tier, scope_level, or the other parameters mean or how they influence the generated document.

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

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

The description clearly identifies the deliverable: a contractor-ready scope of work with material specifications, quality standards, and general conditions for a unit renovation. It distinguishes itself from the estimate by noting it is generated from the same knowledge base but is the document to hand a bidding contractor, though it does not explicitly name a sibling alternative.

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

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

It provides a clear usage context: use this tool when you need the document to hand a bidding contractor. It does not enumerate when not to use it or name alternative tools, so it stops short of fully explicit 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?

With no annotations, the description carries the full burden of behavioral disclosure, and it does so well: it explicitly describes the unknown-name refusal behavior and the private-component response shape (public=False with no repo/description). It does not mention auth, rate limits, or other side effects, but for a simple read-style tool the disclosed behaviors are the most important ones.

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 three short sentences, each earning its place: what the tool returns, what happens for unknown names, and what happens for private components. It is front-loaded with the core purpose and contains 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?

Given there is no output schema and no annotations, the description reasonably covers the main scenarios an agent would encounter: successful public lookup, unknown name refusal, and private component marker. It does not fully specify the public success response structure, but it gives enough behavioral detail for correct invocation and interpretation.

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

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

The schema only provides the parameter name 'name' with no description, so the tool description must compensate. It adds semantic value by specifying 'exact name,' which is a meaningful constraint beyond the bare schema. It does not mention case sensitivity or formatting, but for a single simple parameter this is adequate.

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

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

The description clearly states the operation ('Get one component by exact name') and distinguishes it from the sibling search/list tools by emphasizing exact-name lookup. It also signals the key result shape—verified repo or private marker—so an agent understands what the tool is for.

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 'by exact name' provides clear context for when to use this tool: when the agent has a specific known component name rather than needing to search or list. It does not explicitly name alternatives or state when not to use it, but the contrast with siblings like find_components and search_components is strongly implied.

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

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

With no annotations, the description carries the burden of behavioral disclosure. It explicitly states the data is synthetic, fabricated, and that the payload itself says so, which is valuable context preventing misuse of the returned data. It does not mention side effects, but as a 'get' operation this is reasonably implied.

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 two sentences with no redundant wording. The main purpose is front-loaded, and the clarifying detail about synthetic data adds value without bloat. Every sentence 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?

Given there are no parameters and no output schema, the description provides sufficient context: the tool returns a demo portfolio of synthetic data that is clearly labeled and demonstrates component composition. It could elaborate on the exact structure, but for a simple getter this is adequate.

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

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

The tool has zero parameters, so parameter semantics are trivially satisfied. Per rubric baseline for 0 params is 4; the description adds nothing about parameters because none exist, which is appropriate.

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

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

The description states a specific verb ('Get') and resource ('synthetic demo portfolio'), and explicitly highlights that the data is fabricated and clearly labeled. This is clear, though it doesn't distinguish the tool from siblings like get_ecosystem_overview, so it doesn't fully differentiate.

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

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

The description implies the tool is for demonstration purposes by calling it a 'demo portfolio' and stressing synthetic data, so an agent can infer appropriate use. However, it offers no explicit when-to-use or when-not-to-use guidance, nor mentions alternatives, leaving some ambiguity.

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

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

No annotations are present, so the description carries the full burden. It only says 'Get' and 'at a glance,' which are mild behavioral hints, but it does not explicitly disclose that the operation is read-only, has no side effects, or mention any auth/rate-limit considerations. Most of the text restates the tool name and enumerates content, leaving safety behavior to assumption.

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 two sentences, but the second largely repeats the first, adding only 'category map' and 'new user.' This redundancy is unnecessary and makes the description slightly less concise than it could be.

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

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

Given the absence of an output schema and annotations, the description lists content categories but does not specify the response format, keys, or how the data is structured. For a zero-parameter tool, this is borderline sufficient but still leaves the agent uncertain about the exact output 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?

The tool has zero parameters, and the empty input schema is fully self-descriptive. Since there are no parameters to document, the description does not need to add parameter semantics; the baseline of 4 applies.

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

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

The description clearly states the tool's purpose: retrieving a high-level ecosystem overview containing counts, principle, category map, and package facts. It distinguishes itself from sibling tools like list_components or list_categories by aggregating multiple types of information, though it does not explicitly name an alternative.

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

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

The description provides a usage hint: it is for new users who need this information 'before anything else.' This implies a first-step context, but it does not explicitly say when to prefer this over other tools or list exclusions/alternatives.

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

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

No annotations are provided, so the description carries the full burden. It makes the behavior plain: the tool returns copy-pasteable commands and JSON, implying a non-destructive read operation. It does not claim to execute an installation or modify anything, so the behavior is transparent enough for a 0-parameter informational 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?

Two concise sentences with no filler. The first sentence states the tool's core purpose, and the second adds concrete details about the return content. The structure is fully front-loaded and every word earns its place.

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

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

For a zero-parameter tool with no output schema, the description provides everything an agent needs: purpose, output format, and applicability. There is no missing information that would prevent correct invocation or interpretation 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?

The tool has zero parametersainer and schema coverage is effectively complete. The baseline of 4 applies because there is nothing for the description to clarify about parameters; the tool simply needs no input.

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

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

The description clearly states the tool returns install commands and MCP client configuration for connecting platworks. The verb 'Get' identifies an informational retrieval action锁定 to a specific resource, and the content (pip install line, mcpServers JSON) distinguishes it from the unrelated sibling tools.

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

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

The description communicates when to use this tool: when the user needs installation commands or client configuration for MCP support. It does not explicitly exclude alternatives, but none of the sibling tools serve a similar purpose, so the context is clear enough without additional 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?

Since no annotations are provided, the description carries the full burden of behavioral disclosure. It explicitly states the output is self-contained with inline CSS, no CDN, no scripts, and no tracking, adding useful context about the HTML contents beyond the tool name.

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 two sentences, front-loaded with the main action and key attribute. Every sentence contributes value, and there is no wasted wording.

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 tool with no parameters and no output schema, the description provides essential details about the return type (HTML) and its characteristics. It does not mention error conditions or fallback behavior, but for a simple retrieval tool this is sufficient.

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

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

With zero parameters, the baseline is 4. The description adds no parameter information, but none is needed since the schema is empty and there is nothing to explain.

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 'Get' with a clear resource 'standalone product landing page as HTML' and adds the distinguishing characteristic 'self-contained, no external assets.' This clearly separates it from sibling tools that return components or lists, such as get_component or list_components.

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

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

The description provides no explicit guidance on when to use this tool versus alternatives. It mentions the HTML renders from the same verified catalog as other tools, but does not specify conditions or scenarios where this tool is preferred, leaving the agent to infer usage.

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

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

With no annotations provided, the description carries the full burden of behavioral disclosure, and it delivers meaningful context: it states the output includes component counts, that the order is stable, and that every category appears exactly once. These guarantees are genuinely useful behavioral traits that an agent couldn't infer from the tool name or schema. The only omission is details about the return format, but with no output schema present, the stated guarantees are sufficient for a read-only vocabulary 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?

Two sentences with zero waste. The core purpose is front-loaded, and the behavioral guarantees are packed into a compact second sentence. Every word earns its place.

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

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

For a zero-parameter, read-only vocabulary listing with no output schema, the description is largely complete. It discloses what the tool returns (component counts for the closed category vocabulary) and gives an ordering guarantee. An agent can call it safely and correctly. It could add explicit 'returns a list of {category, count} objects' but the stated context is sufficient for this tool's simplicity.

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

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

With 0 parameters, the baseline is 4 per the rubric — there are no parameters to document. Schema coverage is 100% trivially since there are no properties. The description adds no parameter info because none exists, and this is correct; nothing is missing.

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 ('List the closed category vocabulary'), which is clear and unambiguous. The scope is well-defined by 'closed' — indicating a fixed vocabulary. It doesn't explicitly distinguish among the sibling list tools (list_components, list_private_components, list_public_components), but the distinct resource name 'categories' naturally differentiates it.

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?

For a zero-parameter, read-only vocabulary listing, the description implies usage context implicitly through its scope statement, but it provides no explicit guidance on when to use it vs. the sibling list tools. Since the siblings operate on different resources (components, private/public components), there's low ambiguity risk, so the lack of explicit routing is a minor gap rather than a critical one.

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

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

With no annotations, the description carries the full burden of disclosing behavior, and it does add a meaningful trait: unknown categories produce a typed unknown_category refusal that names valid categories. This goes beyond the name and schema by explaining the failure mode and the closed-vocabulary behavior.

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

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

The description is compact and front-loaded: the first sentence states the core action and optionality, while the second covers an important edge case. Every sentence earns its place with no redundant filler.

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

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

For a simple one-parameter list tool, the description covers the main behavior and the invalid-input case, but it leaves ambiguity around how this tool relates to siblings like list_public_components and list_private_components. It also doesn't describe the shape of the returned component list, though the word 'List' implies an array of components.

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

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

The input schema provides only a nullable string with no description, so schema coverage is effectively 0%. The description compensates by explaining that the category is optional, that categories are a closed vocabulary, and that an invalid value yields a refusal naming valid categories. This gives the agent a clear mental model of the parameter's contract, although it doesn't enumerate the valid categories.

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

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

The description uses a clear verb ('List') and identifies the resource ('ecosystem components'), with the optional category filter stated upfront. However, it does not distinguish itself from similar siblings like list_public_components or list_private_components, so the differentiation is left to the reader.

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 is given for when to use this tool versus alternatives such as list_public_components, list_private_components, find_components, or search_components. The description only mentions the optional category filter, which is a parameter detail rather than usage-direction.

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

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

With no annotations, the description carries the behavioral disclosure burden. It clearly states that output is names only and that private entries by design have no repo URL or description, preventing false expectations. It does not mention pagination or ordering, but for a zero-parameter listing the key behavior is disclosed.

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

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

Two short sentences with the essential scope front-loaded. The second sentence adds useful context about why repo and description are absent, with no redundancy or wasted words.

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

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

For a simple zero-parameter list tool with no output schema, the description explains the return scope and the reason repo/description are missing. It is slightly thin on explicitly routing to list_public_components or list_components, but the sibling names and the 'private' qualifier provide enough context.

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

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

The input schema has zero properties and schema coverage is 100%, so there are no parameters to document. The baseline for zero-parameter tools is 4, and the description appropriately adds no parameter information.

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

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

The description uses a specific verb ('List') and a specific resource ('private components'), and immediately scopes the output to 'names only — no repo, no description claims'. This clearly distinguishes it from sibling tools like list_public_components and list_components.

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

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

The description conveys the context: use this when you need private components and only their names, and it explains why repo/description fields are absent. However, it does not explicitly name alternatives or state when not to use this tool, so routing to a sibling is implied rather than explicit.

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

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

No annotations are provided, so the description carries the full burden. It discloses the filtering criteria (public and verified links) and the practical implication (clonable today), which is useful behavioral context. However, it does not mention whether the operation is read-only, any authentication requirements, or potential rate limits. For a simple list with no parameters, this is adequate but leaves some room for improvement.

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 two sentences with zero waste. The core purpose is front-loaded ('List only public components...'), and the second sentence adds a practical implication ('These are the repositories a user can actually clone today'). Every word 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?

Given the tool has no parameters, no output schema, and is a straightforward list operation, the description is complete. It tells the agent exactly what the tool returns and the criteria for inclusion. No additional details are necessary for correct invocation.

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

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

There are zero parameters, so the schema provides no parameter information. The baseline for 0 parameters is 4, and the description appropriately focuses on the tool's output criteria rather than parameters. It adds meaning about what the returned list contains, which is beyond the empty schema. No parameter explanation is needed.

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

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

The description uses a specific verb ('List') and resource ('public components') with a precise qualifier ('that carry verified repository links'). It clearly distinguishes from sibling tools like list_components (all components) and list_private_components (private ones), making the tool's unique purpose unambiguous.

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

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

The description provides clear context: it lists only public components with verified links, and adds that these are the repositories a user can actually clone today. This implicitly guides when to use it (when you need clonable repos) but does not explicitly name alternatives or state when not to use it. Given the sibling list, the differentiation is effective though not exhaustive.

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

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

With no annotations provided, the description carries the full burden of behavioral disclosure, and it delivers exceptionally: read-only guarantee, honest VARIANCE_NOT_IMPLEMENTED blocked status instead of fabricated variance, missing-budget treated as a blocker never zero, structural refusal of wildcard/aggregate asset ids, and the rationale for declaring core arguments optional so refusals surface as payloads rather than crashes. This is unusually rich and honest behavioral disclosure.

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

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

Roughly a hundred words with the core purpose front-loaded in the first sentence and behavioral details following in logical order. Every sentence earns its place — the parenthetical about optional arguments is the only mildly tangential element. Dense but well organized.

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

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

For a 6-parameter tool with no annotations and no output schema, the description covers behavior richly but leaves two gaps: it does not describe the return structure/format of the review payload, and it does not document individual parameter semantics. The refusal and blocker behaviors are well covered, but the missing pieces keep it from being fully self-sufficient.

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

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

Schema description coverage is 0% across 6 parameters, so the description must compensate for the missing parameter documentation. It only partially does: it implies asset_id rejects wildcard/aggregate values, and variance_oracle_callable gates the bound-variance behavior. But it never individually explains period, db_path, as_of_date, materiality, or how they map to the review behavior. With zero schema descriptions, this is a genuine 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 — a read-only review of one property and one period — and immediately scopes the content: occupancy, typed exceptions, and oracle-bound variance only. This clearly separates it from the sibling tools, which are dominated by components listing, underwriting, and bid evaluation, none of which overlap with operational occupancy/variance review.

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

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

The description establishes clear context for when to use the tool: when an agent needs occupancy change, feed freshness, or typed material exceptions for a single property over a single period. The repeated 'only' qualifiers set explicit boundaries on scope. However, it does not name alternative tools or give explicit when-not-to-use exclusions, which keeps it a step below 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?

With no annotations, the description carries full behavioral disclosure. It explicitly states the output is a range (never a single invented number), mentions age-based risk flags for 1978-or-older builds, and discloses that core arguments are optional to avoid validation crashes, turning missing-input refusals into payloads. This is substantial transparency for a tool with no annotations.

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

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

The description is two paragraphs with a crisp first sentence summarizing the tool. The second paragraph adds essential detail on scaling and the optional argument design. There is no fluff, but the parenthetical about optional arguments is a minor aside. Overall, it is well-structured and concise.

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

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

Given 9 parameters with no schema descriptions and no output schema, the description provides a good high-level overview but lacks details on parameter validation, acceptable values, output format, and error handling beyond the optional argument note. An agent would understand the general purpose but may not know all specifics needed for correct invocation.

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

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

Schema description coverage is 0%, so the description must compensate. It only mentions unit size and finish tier as scaling factors and year_built implicitly via age risk. It does not explain the meaning or usage of market, scope_level, property_class, bedrooms, bathrooms, or unit_sqft. The description adds minimal value over the parameter names themselves, leaving much to inference.

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

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

The description clearly states the tool's purpose: producing per-unit renovation cost ranges with line items and age-based risk flags, sourced from the costmodel KB. It specifies the resource (renovation cost estimates) and the verb (produces ranges). This distinguishes it from siblings like renovation_roi (ROI calculations) and generate_sow (statements of work) by the explicit mention of cost ranges and line items.

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

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

The description explains how the tool works and what it outputs but does not explicitly state when to use it versus alternatives. It implies usage when a renovation cost estimate is needed, but no exclusions or alternative selection criteria are given. The note about ranges instead of single numbers gives some behavioral context but not usage guidance.

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

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

With no annotations, the description carries the full behavioral burden, and it delivers: it discloses the conservative high-cost assumption, the exact ROI formula, the 15% default gate, failure messaging that explains the miss, and the deliberate optionality of arguments to route missing-input refusals as payloads. This exceeds what annotations would typically provide.

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

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

The description is compact and front-loaded: purpose first, then formula, then failure behavior, then the optional-arguments rationale. Every sentence adds information, and there is no filler or repetition of schema contents.

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 four-parameter tool with no annotations or output schema, the description covers the core invocation context: formula, default threshold, conservative cost stance, failure behavior, and why arguments are optional. It is slightly incomplete on which parameters are minimally needed for a meaningful calculation and on the success-response shape, but an agent can reasonably infer these from the formula.

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

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

Schema coverage is 0%, so the description must compensate, and it does meaningfully: it explains total_cost_high as the high-cost denominator, implies rent lift as the difference between target and current monthly rent annualized, and references threshold_pct via the 15% default gate. It does not walk through each parameter by name, but the formula and defaults give enough semantic grounding for correct invocation.

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 ('Check') and a specific resource ('a renovation's rent lift' against an ROI threshold), and the formula makes the exact calculation unambiguous. This is enough to distinguish it from siblings like renovation_estimate or underwrite_run without opening the schema.

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

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

The description strongly implies when to use the tool—whenever a renovation's rent lift needs to be tested against an ROI gate—and states the default threshold. However, it never explicitly says when not to use it or points to an alternative sibling, leaving comparative selection to the agent's inference.

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

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

With no annotations, the description carries the full burden, and it delivers: it discloses case-insensitive matching, the typed missing_argument refusal for a missing query, and that an empty result returns count 0 rather than an error. It also explains why the argument is optional, which is valuable.

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

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

Two tight paragraphs, purpose first, then behavioral edge cases. The parenthetical rationale earns its place by explaining the optional-argument design. No wasted words.

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

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

For one optional parameter, the description covers purpose and edge cases well. However, with no output schema, it doesn't specify the success return payload (e.g., component objects, count, pagination), so agents must guess at the result shape beyond count 0.

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

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

Schema coverage is 0%, so the description must enrich the bare optional string parameter. It does by defining query as a substring, specifying case-insensitivity, and documenting the missing-query behavior. It doesn't specify length or format limits, but the semantics are clear.

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

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

States a specific verb and resource: search components by substring across name, category, tags, and verified descriptions. This clearly identifies the operation and scope, but does not explicitly distinguish it from sibling tools like find_components or list_components, which may overlap.

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

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

The description implies when to use this tool: when a substring match across those fields is needed. However, it offers no explicit comparison to siblings like find_components or list_components, nor any 'when not to use' guidance.

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

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

With zero annotations, the description carries the full burden and exceeds it: it discloses the return format (decimal strings), the inclusion of every statute citation, the requires_competent_human_review=true flag, the refusal-by-type behavior for unknown states, and even the design rationale for declaring the argument optional. This is unusually rich behavioral disclosure for an MCP 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?

Four sentences, front-loaded with the core purpose, and every clause earns its place. The parenthetical explaining the optional-argument design is verbose but materially important for correct invocation. Slightly dense, but not padded.

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

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

The description thoroughly covers output content and refusal behavior, which matters because there is no output schema and no annotations. But with 8 parameters at 0% schema coverage, the input semantics for seven parameters are left to inference, and there is no statement of how parameters combine per state — a meaningful gap for a tool this complex.

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

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

Schema description coverage is 0%, so the description must compensate, but only the state parameter is explained — its supported values, refusal behavior, and optional-argument rationale. The other seven parameters (tax_year, just_value, unit_count, school_millage, non_school_millage, prior_assessed_value, ownership_change_or_qualifying_improvement) are never tied to the assessed-value computation, so an agent cannot know how inputs map to the returned schedule.

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 states a specific verb+resource: a statute-cited property-tax regime schedule for explicitly named supported states (TX CA FL AL). It is unmistakably distinct from the sibling tools, which are all component/underwriting/renovation tools, so an agent can select it correctly without opening any schema. The refusal behavior for unsupported states further pins down scope.

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

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

The description names the exact supported jurisdictions and states that unknown states are refused, giving clear when-to-use guidance. It adds the human-review caveat so the agent knows this is research, not legal advice. It doesn't name an alternative tool by name, but no sibling offers a tax-regime lookup, so an explicit exclusion is unnecessary.

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

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

With no annotations provided, the description carries the full behavioral burden, and it does so strongly. It discloses the iterative bisection method, the fact that debt/tax/equity are re-priced each run, the response fields, the safety guarantee that no price outside a proven bracket is returned, and that missing-input refusals are delivered as payloads rather than validation crashes.

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

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

Three dense sentences cover purpose, algorithm, outputs, safety guarantee, and a quirk about optional arguments. Every sentence earns its place, and the most important information is front-loaded in the first sentence.

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

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

The description is thorough about behavior and outputs, but this is a complex 8-parameter tool with no output schema and no annotations. It doesn't explain what the `inputs` argument should contain or what the required core inputs are, so an agent could struggle to invoke it correctly even though it understands the tool's intent.

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

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

The description adds important meaning for the core parameters: 'target Year-1 post-debt cash-on-cash return' maps to target_coc_pct, 'highest price' relates to min_price/max_price, and 'iteration count' relates to max_iterations. However, with 0% schema description coverage, it still leaves the critical `inputs` parameter unexplained, and several other parameters like agency_spread_pct and benchmark_5yr_treasury_pct are only implied by domain terminology, not actually described.

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 and resource: 'Backsolve the highest price meeting a target Year-1 post-debt cash-on-cash return, via the engine's own search.' This clearly distinguishes it from sibling tools like underwrite_run or evaluate_bid, which imply running at a fixed price or evaluating a proposed bid rather than solving for a price.

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

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

The description provides clear context for when to use the tool: when you need to find the highest price that hits a target cash-on-cash return. It doesn't explicitly name alternatives or state when not to use it, but the 'backsolve' framing makes the intended use case obvious enough for an agent to select it over the siblings.

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

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

With no annotations provided, the description carries the full burden, and it delivers rich behavioral context: the engine is deterministic, returns certified metrics verbatim with the engine version on every response, refuses a canonical missing its tax policy (never guesses), and explains why the argument is declared optional (so refusals arrive as payloads, not validation crashes). This is exemplary disclosure.

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

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

The description is dense but every sentence earns its place — purpose is front-loaded, followed by input requirements, refusal behavior, and the optional-argument rationale. Slightly long, but no wasted words for a tool with a single complex parameter.

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 fully explains return values ('certified metrics (NOI, CoC, DSCR, IRR, equity multiple, yields) verbatim, with the engine version on every response') and covers input requirements and failure behavior. Nothing an agent needs to call it correctly is missing.

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

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

Schema description coverage is 0% and the single 'inputs' parameter is essentially undocumented in the schema (only 'default': null). The description compensates substantially by specifying exactly what the inputs must contain (cohorts, rent curves, opex table, assumptions, tax policy) and referencing the engine schema version, though it does not detail the full v0.1 structure 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?

States a specific verb ('Run') and resource ('deterministic underwriting engine'), and distinguishes itself via 'certified metrics come from the engine, never a model' — differentiating it from model-based siblings like underwrite_backsolve. The purpose is unambiguous.

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

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

The description clearly enumerates what to pass ('full canonical deal inputs (engine schema v0.1) — cohorts, market rent curves, opex table, purchase/debt/exit/fund assumptions, and a property tax policy') and states the required precondition (tax policy present). It lacks an explicit when-not-to-use or named alternative, though 'never a model' implicitly contrasts with underwrite_backsolve.

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