FreeToolHub

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. It correctly frames the tool as advisory by saying 'recommendations,' which signals no destructive side effects, but it does not describe what the recommendations contain, how usage values affect the analysis, or whether any actual merging or removal is performed.

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 at two sentences and front-loads the motivating problem before stating the action. Every sentence contributes to understanding why and when to use the tool, with no filler or redundancy.

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

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

For a simple two-parameter advisory tool, the description sufficiently conveys the expected input and the nature of the output. There is no output schema, so the tool would benefit from slightly more detail on the shape of the recommendations, but the current description is enough to call the tool correctly.

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

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

The input schema already documents both parameters fully, including the JSON array form for tools and the default for targetToolCount. The description adds helpful context that the tools list should include usage ('tool list and usage'), but it does not add any syntax or format details beyond what the schema provides.

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 phrase 'get keep / merge / remove recommendations' applied to a tool portfolio, and it ties the outcome to the 10–15 tool guideline. This clearly communicates what the tool does and roughly distinguishes it from calculators and search-like siblings, though it never names a sibling 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?

The opening sentence, 'Too many MCP tools makes agents pick the wrong one,' provides a concrete trigger condition, and 'get under the 10–15 tool guideline' defines the goal. It does not mention alternatives or exclusions, but the context is clear enough for an agent to know when this tool is appropriate.

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. It discloses that the tool produces a report with a remediation list, which implies a read-only analysis of the boolean inputs rather than active probing or mutation. However, it doesn't explicitly state that it does not execute commands or contact the live server, and it doesn't describe the report's format or how inputs map to outputs. Adequate for a passive analysis tool, but not rich.

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 no filler; the verb and framework are front-loaded in the first clause, followed by a compact list of report coverage and the deliverable. It earns the words it uses, though it could tighten the category list into actual parameter mapping. Efficient and well-ordered.

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 nine parameters, no required fields, no output schema, and no annotations, the description conveys the purpose and deliverable but leaves gaps: it doesn't explain whether all booleans must be answered, what the output structure looks like, or how the audit is computed from the inputs. The report-topics list partially covers this, but an agent still lacks full clarity on the invocation 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 100%, so the baseline is 3; the schema already documents all nine boolean parameters. The description adds only a thematic echo of the report categories (authentication, secret exposure, etc.) that loosely correspond to the parameters, without explaining how each flag feeds into the audit. It provides no additional meaning beyond the schema, so the baseline 3 stands.

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 ('Audit') tied to a concrete resource (an MCP server) and a named framework (OWASP MCP Top 10). It enumerates the report's coverage areas (authentication, path traversal, command injection, secret exposure, supply-chain risk) and the deliverable (a concrete remediation list). This clearly differentiates it from the calculation-heavy sibling set and the related score_mcp_server_trust, since nothing else in the list performs an OWASP-based audit.

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 intended use — auditing a server's security posture against OWASP — is clearly implied, and the verb 'Audit' sets the context. However, the description never distinguishes this tool from its close sibling score_mcp_server_trust, which targets the same domain, nor does it state when one should be chosen over the other. No exclusion criteria or alternatives are named, leaving the routing decision to the agent.

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

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

With no annotations, the description itself discloses that the result is an 'estimate' and that it relies on 'latest CDN data,' which suggests current tax information but remains vague. It does not disclose assumptions, state-versus-federal scope, or how the mentioned components surface in the output, leaving the agent to infer 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?

Three very short sentences front-load the purpose and supporting context. Every phrase adds information, although 'CDN' is an unexplained acronym; on structure alone it is exemplarily 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?

The description captures purpose, scope, components, and data freshness, but with no output schema and no annotations it leaves unstated what exactly is returned and whether state income tax is included despite the state parameter. For a 5-parameter calculator this is adequate but not completely self-contained.

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 description need not repeat parameter docs. The phrase '1099-K income' and 'reselling, gig work' adds contextual meaning to grossReceipts and expenses, but it does not clarify options like state or costOfGoodsSold beyond the schema.

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

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

The description names a specific verb ('Estimate'), a specific income type ('1099-K income'), and an example context ('reselling, gig work'). It also lists components (SE tax, QBI, quarterly 1040-ES) that differentiate it from generic tax calculators among the 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?

The description implies the use case—1099-K income from reselling or gig work—but it never states when not to use it or names alternatives such as calculate_se_tax or calculate_freelancer_tax. Given the large sibling set of tax calculators, the omission is noticeable, though the 1099-K qualifier gives some 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 behavioral disclosure burden. It states the main output concept and mentions target profit analysis, but it does not disclose assumptions, edge cases, default behavior for targetProfit, or the exact response format. This is adequate for a simple calculator but leaves notable gaps.

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

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

The description is very short and front-loads the core purpose. The first sentence is efficient; the second sentence is telegraphic but provides useful extra scope. Minor structural issue: the second fragment is not a complete sentence, though it adds value.

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 calculation tool with fully described schema parameters, the description is mostly sufficient: it communicates the output concept and mentions target profit analysis. Missing assumptions such as contribution margin calculation and handling of invalid cases, plus the lack of an output schema, leave some contextual gaps.

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

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

Schema description coverage is 100%, so the baseline is already strong. The description adds meaning by explaining that fixed costs and contribution margin are used to compute units to sell, and that target profit is part of the analysis. It does not provide actual formulas, but it does relate the parameters to the calculation concept.

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 tool as a break-even calculation, stating the output ('units to sell to cover fixed costs') and two relevant analyses ('contribution margin, target profit'). It is unambiguous and distinct from the many calculate_* sibling tools by topic, though it lacks an explicit action verb in the description, relying partly on the tool name for the verb.

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 the tool: for break-even unit calculations or target profit analysis. It does not explicitly state when not to use it or mention any alternative sibling tool, so the agent must infer selection based on the topic rather than receiving explicit routing guidance.

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

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

With no annotations, the description carries the behavioral burden. It discloses key factors (short/long-term, NIIT, state tax, latest brackets) but does not discuss limitations, assumptions, or edge cases, which a tax calculator would benefit from.

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 brief and front-loaded with the main purpose. Each clause adds information, but the ambiguous 'CDN' acronym (likely 'current' or 'Canada') creates confusion and slightly detracts from clarity.

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?

No output schema is provided and no annotations exist, so the description should clarify expected output and behavior. It does not explain whether the result is a tax amount, breakdown, or marginal rate, nor does it mention assumptions about required inputs like ordinaryIncome. The ambiguous 'CDN' further reduces completeness.

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

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

Schema coverage is 100%, so baseline is 3. The description adds slight meaning by connecting state to state tax and ordinaryIncome to NIIT, but it does not elaborate on parameter usage beyond what the schema already states.

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

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

The description clearly states the tool calculates US capital gains tax on stock/crypto, with short vs long-term, NIIT, and state tax. It is specific enough to distinguish from sibling calculators like estate or 1099-K tax, though it lacks an explicit verb.

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 context is clear: use this for US capital gains tax on stocks/crypto. It implies when it applies but does not explicitly state when not to use it or name alternatives, leaving exclusions to inference.

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

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

With no annotations, the description carries the full behavioral burden. It does disclose that sales tax, trade-in, and down payment are included, but it introduces a major ambiguity: it says 'latest CDN sales tax rates' while the schema says 'US state for sales tax lookup.' It also does not explain edge cases like missing state/province, defaulted rates, or output structure.

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 appropriately short and front-loaded with the main outputs first. Every clause adds relevant information, though the ambiguous 'CDN' abbreviation and the tax-rate claim could confuse more than they help.

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?

This is a 7-parameter tool with no output schema and no annotations, so the description needs to do substantial work. It summarizes outputs and inputs at a high level but fails to reconcile 'CDN sales tax rates' versus 'US state', omits default behaviors (loanTermMonths, salesTaxRate), and lacks enough detail for an agent to correctly choose and invoke it with confidence.

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

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

Schema description coverage is 100%, so the schema already documents every parameter. The description adds some value by naming the included factors (sales tax, trade-in, down payment, amortization), but it does not clarify parameter-specific semantics beyond what the schema provides, and its tax-rate source claim conflicts with the schema's US-state wording.

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

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

The description names a specific verb and resource ('calculate' a car loan) and states the core outputs: monthly payment, total interest, and amortization. It is clear enough to distinguish from most siblings, though it does not explicitly contrast with similar tools like calculate_mortgage or calculate_student_loan.

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 guidance about when to use this tool versus alternatives. The name and phrase 'car' imply use for auto loans, but the description never states exclusions or names alternative siblings for different loan types, leaving the decision to inference.

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

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

With no annotations provided, the description carries the full burden. It discloses that it uses the latest CDN inflation rate for the inflation-adjusted value, which is a non-obvious behavior. However, it does not mention any side effects (none expected for a calculator) or potential data source dependencies beyond the inflation rate, which is a minor gap.

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

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

The description is compact: two sentences, front-loaded with the core purpose, and each phrase adds value. It avoids fluff and clearly communicates the tool's function and a key data source in minimal 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 calculator tool with no output schema and full parameter schema documentation, the description is quite complete. It mentions the return values and a key external data source (CDN inflation rate). Missing details like whether monthly contributions are added at the beginning or end of the period are minor and not critical for typical use.

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

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

Schema description coverage is 100%, so the schema already documents all parameters. The description adds meaningful context by mentioning 'monthly contributions' and 'inflation-adjusted value', clarifying that monthlyContribution is supported and that inflationRate affects the output. This adds value beyond the basic schema descriptions.

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

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

The description clearly states the tool's purpose: compound interest with monthly contributions, and explicitly lists the return values (final balance, total interest, inflation-adjusted value). It is distinct from the many sibling tax and ROI calculators, focusing on a specific financial calculation.

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 usage for financial planning scenarios involving compound interest and contributions, but does not explicitly state when to use this tool versus alternatives like calculate_roi or calculate_freelancer_pricing. It lacks explicit exclusions or alternative guidance, though the purpose is clear enough to infer common use cases.

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 does add useful behavior context, notably that the calculation uses 'latest CDN payment processor fees' and accounts for multiple cost layers. However, it does not disclose return format, whether the result is per-order or aggregate, or any caveats about fee assumptions.

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 zero filler. The core purpose and the distinguishing 'latest fees' behavior are front-loaded, and every phrase 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?

The description is adequate for a straightforward calculation tool, but with no output schema and no annotations, it leaves out the return value shape and units. It also omits any mention of whether all inputs are required or how missing optional fields like shippingCost are treated.

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

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

Schema description coverage is 100%, so the schema already documents all six parameters. The description adds general context by naming cost categories like platform fees and payment processing, which map to the platform and paymentProcessor parameters, but it does not add detailed parameter-level semantics beyond the schema.

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

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

The description clearly states the tool calculates dropshipping profit and enumerates the cost components it accounts for (product cost, platform fees, payment processing, ad spend). However, it does not differentiate from the closely related sibling calculate_reseller_profit, which could represent the same underlying use case.

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 calculate_reseller_profit, calculate_break_even, or calculate_roi. The context of dropshipping is implicit, but no explicit when-to-use or when-not-to-use conditions are stated.

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

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

With no annotations provided, the description carries the behavioral burden, and it adds meaningful details: the specific 2026 exemption threshold and marginal rate. The phrase 'includes marital deduction' also tells the agent how spousal inheritance factors into the calculation. It still omits potential caveats like state taxes or how the exemption interacts with deductions, but it is far from a bare summary.

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 one dense, front-loaded sentence that covers what the tool does, the relevant exemption, the rate, and a key deduction behavior. Every clause earns its place with no filler.

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

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

For a simple two-parameter calculator with no output schema, the description provides enough context: the computation domain, tax year assumption, exemption amount, rate, and marital deduction behavior. It does not describe return formatting, but the calculation intent is clear and low-risk.

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

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

Schema description coverage is 100%, so the schema already documents both 'estateValue and spousalInheritance. The description does not materially add meaning beyond the schema, so the baseline score of 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?

The description names a clear verb and resource: 'Calculate federal estate tax.' It goes beyond the tool name by specifying the 2026 exemption amount, the 40% rate, and marital deduction, which distinguishes it from the many calculate_* siblings in the list.

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 intended use is implied clearly by the tool name and first sentence: this is for computing federal estate tax. However, there is no explicit guidance about when not to use it, or how it differs from related tax calculators. The description gives context for use but no exclusions or alternative 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 must carry the full behavioral burden, but it only names the inputs and output without explaining how overhead/profit margin are applied, what 'milestone splits' means, or what the response looks like. The unbacked mention of milestone splits is vague.

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 core conversion and key components with no filler. Every phrase adds meaning, though milestone splits could use elaboration.

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 calculator with a fully documented schema, the description conveys the purpose, but without an output schema it leaves 'milestone splits' undefined and does not clarify the expected result format. The calculation defaults are only discoverable in the schema, not the description.

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 parameters are already documented with defaults. The description adds no parameter-level detail beyond what the schema provides, and the mention of milestone splits does not correspond to any input parameter.

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

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

The description uses a specific verb-resource pair ('Turn hourly rate into project quote') and names the calculation components (overhead, profit margin, milestone splits). This clearly separates it from sibling calculators like calculate_freelancer_tax and calculate_break_even.

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

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

The description gives clear context: use it when converting an hourly rate and estimated hours into a project quote. It does not explicitly state when not to use it or name alternatives, so it falls just short of 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?

No annotations are present, so the description takes on the full behavioral burden. It discloses that the tool returns a quarterly payment figure and that it uses 'latest CDN data,' which adds a data-freshness trait beyond the schema. It does not discuss assumptions or limitations, but for a non-mutating calculator the disclosed behavior is reasonably informative.

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 short and front-loaded: it states what the tool calculates, then the output, then the data source. Every piece adds some value, though the phrase 'CDN data' is vague enough that it slightly weakens the polish and prevents a 5.

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 that there is no output schema, the description should explain return behavior more fully, and it only says 'Returns quarterly payment.' It also leaves the tax year, output breakdown, and how optional inputs affect the state-tax portion implicit. For a tax calculator of this complexity, the description is minimally adequate but not complete on its own.

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

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

Schema description coverage is 100%, so the baseline is 3. The description lists tax components but does not add field-level meaning beyond the schema, such as how businessExpenses interact with grossIncome or whether state is required for state tax calculation. The schema already carries the parameter documentation reasonably well.

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 'Complete freelancer tax' and enumerates SE tax, QBI deduction, and federal/state income tax, clearly identifying both the operation and its scope. Saying 'Returns quarterly payment' gives the caller the result type, which also helps distinguish this tool from narrower siblings like calculate_se_tax or calculate_quarterly_tax.

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 is implied that this is the comprehensive freelancer tax calculator, but the description never explicitly says when to use it over siblings like calculate_se_tax, calculate_quarterly_tax, or calculate_1099k_tax. The agent must infer the boundary from the word 'complete' and the tool name rather than being told the decision rule.

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 does add useful context: pricing date, per-runner rates, allowance handling, and an extra before/after price-cut report. However, it does not spell out assumptions or limitations, such as how plan allowances are applied or that this is a rough estimate rather than an actual invoice.

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 clauses deliver the core purpose, pricing basis, allowances, and an extra output with no wasted words. The most decision-relevant information is front-loaded, and 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?

For a calculation tool with a fully documented schema, the description is nearly complete: it states the rates, the allowance behavior, and the historical comparison output. It lacks only a brief statement of assumptions or edge cases, which would make it fully self-sufficient given no output schema.

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

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

Schema description coverage is 100%, so the structured schema already documents every parameter. The description adds value by supplying the exact current rates per runner type, but it does not deepen meaning around plan, publicRepo, or how the minutes combine. 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?

The description names a specific verb and resource ('Estimate a GitHub Actions monthly bill') and immediately narrows scope with exact runner rates, plan allowances, and the pre-cut comparison. This clearly distinguishes it from sibling calculate_* tools by domain, so an agent can select it without inspecting other definitions.

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

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

The description gives clear contextual guidance: it is for estimating GitHub Actions spend with January 2026 rates and plan allowances, and it advertises a historical comparison. It does not explicitly list alternatives or when not to use it, but the domain-specific framing makes the intended use unmistakable.

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 provided, so description carries full burden. It adds 'LTV limits included' but doesn't disclose whether the tool is read-only, any auth requirements, or output format. It is a calculation tool, so likely pure, but the description doesn't explicitly state non-mutating 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?

Two concise sentences with no fluff, front-loading the main purpose. Every word adds value.

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?

No output schema, no annotations. Description lists outputs but not their structure or units. For a 4-param tool, the description is adequate but leaves gaps about return format and assumptions.

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

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

Schema coverage is 100%, so baseline 3. The description doesn't add param-specific meaning beyond the schema, though it references LTV limits as an input to calculations.

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 'calculate' and outputs: home equity, max HELOC borrowable amount, monthly payments, and LTV limits. This distinguishes it from sibling calculators like calculate_mortgage or calculate_car_loan.

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 alternatives. It doesn't mention that this is for home equity/HELOC scenarios or that mortgage payment-only calculations should use calculate_mortgage.

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 behavioral disclosure burden. It usefully discloses the calculation scope (federal, FICA, state) and that it uses the latest limits, but it leaves ambiguity about 'CDN limits' and does not explain how optional inputs like state or marginalRate affect the calculation or what the output looks like.

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, with the core action in the first sentence. The phrase 'Latest CDN limits' is unclear and slightly undermines the otherwise efficient 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?

For a five-parameter calculator with no output schema and no annotations, the description gives the calculation scope but leaves meaningful gaps: whether state tax is included when state is omitted, what 'CDN limits' refers to, and what the returned value represents.

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

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

Schema description coverage is 100%, so the schema already documents all five parameters. The description adds no parameter-level detail beyond broadly mentioning contributions and state, which matches the baseline for fully covered schemas.

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 ('Calculate') and a specific resource ('tax savings from HSA and FSA contributions'), then sharpens scope with 'Federal + FICA + state tax savings.' This clearly separates it from sibling tax calculators such as calculate_payroll_tax or calculate_freelancer_tax.

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 intended use case is implied by the description: it is for HSA/FSA contribution tax savings. However, it never explicitly states when to choose this tool over the many sibling tax calculators, nor does it mention exclusions or 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?

With no annotations, the description carries the full behavioral burden. It discloses the data source ('latest IRS brackets from CDN data'), the scope (federal and state), and the calculation outputs (bracket-by-bracket, marginal vs effective). It does not mention limitations (e.g., no AMT, US-resident only) or side effects, but for a calculation tool this is adequate. It adds context beyond the obvious 'calculates tax.'

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 no wasted words. The main purpose is front-loaded ('US income tax for 2026'), followed by specific outputs and data source. Every word earns its place; it is concise and well-structured.

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 5 parameters and no output schema, the description should explain return values. It lists the key outputs (federal bracket-by-bracket, state tax, marginal vs effective rate), which gives an agent a clear idea of what the tool returns, though it does not specify the exact format (e.g., a single number vs an object). It also does not mention standard deduction handling, but the schema covers deduction parameters. For a calculator, this is reasonably 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?

The input schema covers 100% of parameters with descriptions, so the baseline is 3. The tool description does not add meaning to any specific parameter beyond what the schema already provides; it mentions 'state tax' and 'marginal vs effective' which relate to state and grossIncome, but these are already explained. The description does not clarify parameter interactions (e.g., how preTaxDeductions affect federal brackets), so it adds no extra 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 clearly specifies a unique resource ('US income tax for 2026') and distinct functionality (federal bracket-by-bracket, state tax, marginal vs effective rate). It is easily distinguished from siblings like calculate_1099k_tax, calculate_capital_gains_tax, and calculate_freelancer_tax, which target specific income types. The inclusion of the year and data source adds precision.

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 it is for general US personal income tax, not for specialized forms like 1099-K, capital gains, or self-employment. However, it does not explicitly state when to use this tool versus alternatives, such as 'use for W-2 income' or 'not for self-employment.' It provides clear context (federal+state, 2026) but lacks explicit exclusions.

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

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

There are no annotations, so the description must carry behavioral context. It does clarify that this is a calculation using the DIME method rather than a data-mutating operation, but it does not describe output format, assumptions, or limitations such as it being an estimate only.

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 names the tool's purpose and immediately explains the acronym. It is tight, scannable, 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?

The described method covers all major parameter groups and the schema fully documents inputs, making the tool invocable. However, with no annotations and no output schema, an agent still misses information about the expected result format and underlying calculation assumptions.

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

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

Schema description coverage is 100%, so the schema already documents all parameters fully. The description adds some value by mapping DIME categories (Debt, Income, Mortgage, Education) to the parameters, but it does not introduce new semantic detail beyond that.

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 ('Calculate'), a specific resource ('life insurance needs'), and a named method (DIME) with its components expanded. This cleanly distinguishes the tool from the many other calculate_* finance 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 is given about when to choose this tool over alternatives, nor any exclusions. The only usage signal is the tool's name and the DIME method reference, leaving the agent to infer appropriateness.

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 disclosure burden. It helpfully lists the main outputs and connects extra payments to interest savings, but it does not state assumptions such as ignoring fees/taxes, compounding frequency, or output formatting. This is adequate but not fully 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 a single, compact sentence that front-loads the resource and enumerates the key outputs. There is no filler or redundant wording, making the tool's value easy to scan quickly.

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 should more thoroughly explain what the agent receives. It lists output categories, but does not define their units or structure, and it does not clarify assumptions or how the optional extraMonthlyPayment changes all outputs. It is minimally viable but has clear gaps.

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

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

Schema description coverage is 100%, so the schema already documents principal, interestRate, termYears, and extraMonthlyPayment. The description adds a small amount of meaning by linking extraMonthlyPayment to 'interest saved,' but it does not substantially enhance the parameter semantics beyond the schema.

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

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

The description identifies the resource ('any fixed-rate loan') and the computed outputs (monthly payment, total interest, payoff time, interest saved by extra payments). It is clear, but it does not include an explicit verb or directly contrast with specialized siblings like calculate_mortgage or calculate_car_loan, so differentiation is more implicit than explicit.

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?

'Any fixed-rate loan' provides an implied scope and suggests broad applicability, but the description does not say when to prefer this generic calculator over the many specialized loan siblings. No alternative conditions, exclusions, or 'use X instead' guidance is present.

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 must carry the full burden of behavioral disclosure. It fails to state that the operation is read-only (a pure calculation), describe the output format (e.g., whether it returns both margin and markup in a single object), or address edge cases like conflicting inputs (e.g., both price and marginPct provided). The description only lists capabilities, not behavioral constraints or side effects.

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 sentence that is reasonably concise but slightly run-on, listing three related capabilities without clear separation. It front-loads the core function (gross margin and markup) but could be structured with bullet points or semicolons for readability. It does not waste words, so it earns a 4.

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 no annotations, the description must explain what the tool returns and how to use its modes. It fails to specify the output structure (e.g., a result object containing margin, markup, and discount impact), nor does it clarify which parameters to provide for direct versus reverse calculations. The schema hints at these patterns but the description does not synthesize them, leaving an agent without a complete picture.

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% with clear per-parameter descriptions (e.g., 'omit if you are solving from a target'). The tool description does not add semantic detail beyond what the schema already provides; it only summarizes the overall purpose. Per the rubric, a baseline of 3 is appropriate when the schema fully documents parameters, and the description adds no extra value here.

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

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

The description clearly states the tool's function: it computes gross margin and markup, supports reverse pricing from a target, and evaluates discount impact. It explicitly names the resource ('the same deal') and distinguishes itself from the many sibling calculators by focusing on margin/markup rather than taxes, loans, or break-even. No ambiguity about what it 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?

The description offers no guidance on when to use this tool versus alternatives. It does not mention any prerequisites, exclusions, or conditions that would steer an agent to choose it over, say, calculate_break_even or calculate_freelancer_pricing. The phrase 'for the same deal' is too vague to constitute 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 provided, the description carries the behavioral burden alert and does disclose one important runtime trait: latest CDN mortgage rates are used for defaults, implying live or externally sourced rates. It does not disclose assumptions like PMI applicability thresholds or the default loan term, so behavioral transparency is partial.

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 terse sentences with no filler: it front-loads the output composition, then adds the key default-rate behavior. Every clause earns its place and nothing needs to be cut.

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 lack of an output schema is partially offset by naming the full PITI breakdown, so the agent knows what the tool returns. However, important completion details are missing, such as what default loan term is used when loanTermYears is omitted and how PMI is derived when it is not a schema parameter.

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 all six parameters are already documented in the schema. The description adds only high-level output categories and the CDN default-rate behavior, but it does not explain parameter relationships such as down payment percentage affecting PMI or the units 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 clearly identifies a specific calculation: monthly mortgage payment with a detailed P&I plus property tax, insurance, and PMI output, framed as a full PITI breakdown. This differentiates it from sibling calculators like calculate_car_loan or calculate_compound_interest.

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 intended context is implied by "mortgage" and the note about CDN rates, but the description does not explicitly say when to prefer this tool over alternatives or when not to use it. There is clear context, but usage guidance is left to inference rather than stated.

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

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

With no annotations provided, the description carries the behavioral disclosure burden. It does disclose a key behavioral trait: it runs real tax brackets before and after the raise to handle bracket crossings. However, it does not mention what taxes are included (e.g., federal vs. state), what the output contains, or any limitations, leaving meaningful gaps.

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

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

The description is two sentences with no wasted words. It front-loads the core purpose and then adds a valuable methodological detail that helps agents understand why this tool is not a simple marginal-rate calculation.

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 schema covers all parameters and the description explains the core method, but there is no output schema and no annotation to clarify return values, tax scope, or edge cases like how state tax is handled. For a 6-parameter financial calculator, this leaves some ambiguity about what the agent will receive after 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 100%, so the schema already documents all six parameters. The description adds context about the calculation method but does not add meaning to any specific parameter beyond what the schema provides, matching 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 states a specific verb and resource: calculating what a raise is actually worth after tax. It also differentiates the tool's method by emphasizing real brackets before and after and explicitly contrasting with a flat marginal rate, making it distinct from sibling tax calculators.

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 after-tax raise calculations, but it does not explicitly state when to use this tool versus alternatives like calculate_income_tax or calculate_payroll_tax. There are no exclusions or conditions given, so usage context 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?

With no annotations provided, the description carries the burden of behavioral disclosure. It adds useful context about coverage ('All 50 states') and data recency ('Latest CDN data'), but it does not disclose calculation assumptions such as FICA caps, how retirementContribution affects taxable income, or the output format.

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 concise sentences with the core action and deduction categories front-loaded. The coverage and data-freshness statement is brief and relevant, with no filler or restatement of the tool name.

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

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

For a 4-parameter calculator with no output schema or annotations, the description gives a clear summary and the schema fills in parameter details. Still missing are the exact return shape, treatment of retirementContribution as pre-tax, and behavior when state is omitted, so completeness is adequate but not thorough.

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 all four parameters already have meaningful descriptions in the schema: state, grossSalary, filingStatus, and retirementContribution. The tool description adds no deeper parameter semantics, so the baseline of 3 applies.

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

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

The description states a specific verb ('calculate') and resource ('paycheck deductions') and enumerates the deduction types: federal tax, Social Security, Medicare, and state tax. This clearly distinguishes it from sibling tools such as calculate_freelancer_tax or calculate_capital_gains_tax.

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 'paycheck deductions' provides clear W-2 payroll context, and 'All 50 states' signals the intended geographic scope. However, it does not explicitly name alternatives or state when not to use this tool, such as for self-employment or 1099 income.

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. It mentions 'Latest CDN data' indicating the tool uses current data, which is useful. However, it omits details about potential reliance on external data sources, typical usage patterns, or limitations, leaving some ambiguity.

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 short and efficient, with the formula front-loaded. It avoids repetition of schema details, though it could include a brief mention of parameter combinations without bloating. Overall, it is appropriately sized.

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 includes the core formula and data freshness, which covers the main calculation logic. However, with no output schema, it doesn't clarify the return format (e.g., payment schedule, yearly totals). This is a minor gap given the tool's simplicity, but the description is otherwise self-contained.

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 describes each parameter at 100% coverage, so the schema already provides full meaning. The description adds the 'SE tax + income tax divided by 4' formula, which clarifies how annualIncome and businessExpenses may be used, but it does not provide additional details beyond that. This aligns with the baseline of 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 clearly states the tool calculates quarterly estimated tax payments (Form 1040-ES) and specifies the formula (SE tax + income tax divided by 4). It distinguishes itself from siblings like calculate_se_tax and calculate_1099k_tax by focusing on the quarterly payment calculation.

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 this tool is for quarterly estimated tax calculations, which is a clear use case. However, it does not explicitly mention alternatives or when not to use it, such as for annual tax filings or specific tax forms like 1099-K.

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

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

With no annotations, the description carries the full behavioral burden. It does disclose useful behavioral context by naming the 30% rule and DTI ratio, and it suggests the output is a comfortable rent range. However, it does not state assumptions such as gross vs. net income or how the two rules are combined.

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, tight sentence with no filler. It front-loads the primary question and concisely lists key method components, though it could be slightly more explicit about the action it performs.

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 calculator with two parameters and no output schema, the description is nearly adequate but still leaves gaps. It mentions the output concept ('comfortable rent range') but omits usage context and exact calculation behavior, which an agent would need to invoke it confidently.

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

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

Schema description coverage is 100%, so the baseline is 3. The description adds some interpretive value by implying monthlyIncome drives the 30% rule and monthlyDebts drives the DTI ratio, but it does not provide additional formatting, required input details, or edge-case semantics.

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 conveys the tool's purpose through the question 'How much rent can you afford?' and identifies its method ('30% rule, DTI ratio, comfortable rent range'). This distinguishes it from sibling tools like mortgage or ROI calculators, though it lacks an explicit verb like 'calculate'.

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 about when to use this tool versus alternatives such as calculate_mortgage or calculate_rental_roi. There are no conditions, exclusions, or context hints beyond the general 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?

With no annotations provided, the description must disclose behavioral traits. It mentions that the calculation 'Includes vacancy and management,' which adds context about the model's assumptions. However, it does not describe the return format, whether defaults are applied, or any limitations. The description is not misleading but leaves out significant behavioral details.

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 short sentences with no redundancy. The purpose is front-loaded, and the key metrics are listed efficiently. Every word earns its place, and it is appropriately sized for the tool's simplicity.

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 6 parameters and no output schema, the description should clarify return behavior and assumptions. It lists outputs but does not specify the format or whether they are provided together. It also omits mention of defaults for vacancyRate and managementRate, though these are in the schema. For an agent to call it correctly, the description is adequate but not comprehensive.

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. The description does not add meaning beyond the schema; it mentions vacancy and management, which are already documented with defaults. It does not clarify relationships between parameters or provide examples, so it adds no additional semantic 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 clearly states the tool's purpose: calculating rental property ROI with specific metrics (cap rate, cash-on-cash return, NOI, annual cash flow). It specifies the resource (rental property) and distinct outputs, making it readily distinguishable from generic calculate_roi or other finance calculators.

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 usage for rental property ROI but does not explicitly state when to use it over alternatives like calculate_roi or calculate_mortgage. There is no mention of exclusions or selection criteria, though the focus on rental property provides some implicit context.

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 are absent, so the description carries full burden. It discloses that it relies on latest CDN platform fee data, which is a useful behavioral trait. However, it does not explain the return format (e.g., a comparison report vs a single number), whether it makes external network calls, or how optional parameters like state and shippingCost affect the calculation.

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-loads the primary purpose, and includes a relevant detail (CDN fee data) without fluff. It earns its length.

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 no annotations, the description should clarify what the tool returns and how the comparison is presented. It fails to do so, leaving the agent uncertain about the output structure. It also doesn't mention whether all platforms are always included or if the result is an array.

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 descriptions for all four parameters (100% coverage), so the description doesn't need to add parameter-level details. It does not provide any additional semantics beyond the schema, which aligns with the baseline 3 for high schema coverage.

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 the verb 'Compare' with a specific resource ('real profit across reselling platforms'), names concrete platforms (eBay, Poshmark, Mercari), and adds 'after fees' to clarify the scope. This distinguishes it from sibling tools like calculate_dropship_profit or calculate_break_even.

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 comparing reselling platform profits, but it does not explicitly state when to use it over alternatives such as calculate_dropship_profit or calculate_break_even, nor does it provide exclusions or conditions. The mention of 'latest CDN platform fee data' suggests a dependency but not when to prefer this 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?

No annotations are provided, so the description carries the full burden. It discloses key behavioral aspects: outputs are in today's dollars (implying inflation adjustment) and include a withdrawal-rate-based income estimate. However, it does not state assumptions (e.g., compounding frequency, tax treatment), limitations, or how the gap is defined. This is moderate transparency but leaves several behavioral details unspoken.

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, front-loaded sentence that immediately communicates the tool's core purpose and key outputs. It is efficient with no filler words. It could slightly improve by mentioning optionality or assumptions, but for its length it is well-structured.

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

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

With 9 parameters, no output schema, and no annotations, the description must do more to enable correct usage. It lists output variables but does not define 'gap', explain the inflation adjustment methodology, or mention that some parameters are optional. An agent might call this tool without knowing whether Social Security or other income is required, or what the default withdrawal rate is. The description is insufficient for a tool with this complexity.

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

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

Schema description coverage is 100%, so the baseline is 3. The description does not add any parameter-specific meaning beyond listing outputs; it does not explain how parameters like annualReturnPct or withdrawalRatePct interact, nor does it clarify optional parameters (withdrawalRatePct, otherRetirementIncome). The description adds no semantic value over the schema, so a 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?

The description clearly states the tool computes a retirement projection with specific outputs: projected nest egg, sustainable income, gap, and required monthly contribution. It uses a specific verb ('calculate' implied) and resource (retirement), and while it doesn't explicitly name sibling tools, it is distinct enough from the many other calculators in the sibling list.

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 guidance on when to use this tool versus alternatives such as calculate_compound_interest or compare_401k_vs_roth. No exclusions, no conditions, and no mention of scenarios where a different tool would be more appropriate. The agent is left to infer usage solely from the tool name and sibling list.

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

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

No annotations are provided, so the description carries the full burden of behavioral disclosure. It states the metrics computed but does not disclose whether the tool performs a single calculation or multiple, how it handles missing optional parameters (e.g., clicks, adSpend, conversions), whether it returns all metrics at once, or any assumptions about currency/format. For a calculation tool with no annotations, this is a meaningful gap.

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

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

The description is two short sentences and front-loads the key metrics. It is efficient and scannable, though the second sentence ('Facebook, Google, TikTok ad analysis.') is somewhat redundant with the first and could be merged or expanded with usage guidance.

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 no annotations, the description should clarify what the tool returns and how it behaves with partial inputs. It does not explain whether all five metrics are always returned, what happens when optional parameters are omitted, or how the metrics relate to each other. For a 5-parameter calculation tool, this is incomplete.

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

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

Schema description coverage is 100%, so the schema already documents each parameter's purpose. The description adds the metric names (ROI, ROAS, net profit, CPA, CPC) and maps them to the marketing context, which helps an agent infer which parameters feed which metric, but it does not add detail beyond the schema's field descriptions. 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?

The description names a specific verb ('calculate') and resource ('ROI, ROAS, net profit, CPA, CPC for marketing campaigns'), and mentions the ad platforms (Facebook, Google, TikTok). It is clear about what the tool computes, though it does not explicitly distinguish itself from the sibling calculate_rental_roi or calculate_dropship_profit beyond the marketing-campaign context.

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 usage for marketing campaign analysis by listing relevant metrics and platforms, but it does not state when to prefer this tool over alternatives like calculate_break_even or calculate_rental_roi, nor does it give exclusions or prerequisites. The context is clear enough for a marketing ROI scenario, but no explicit when/when-not guidance is provided.

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

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

No annotations are provided, so the description carries the burden. It mentions using 'latest IRS brackets from CDN data', indicating up-to-date rates and a data source, which is useful. However, it does not disclose what happens to state tax input (ignored or used for state-level calc) or potential limitations like dependency on CDN availability.

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?

Single sentence, front-loaded with the core purpose, including key details (15.3%, QBI, quarterly payments) and data source. 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?

Given the tool is a calculation tool, the description covers the essential purpose and inputs. No output schema is provided, but the description mentions what is calculated (tax, QBI, quarterly payments) which indicates outputs. It lacks detail on how state tax might affect output, but the core functionality is adequately specified for a calculator tool.

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 parameters are fully described. The description adds context that netEarnings is the primary input for the core calculation, and hints that state and filingStatus may factor into the calculation but does not specify how. This adds value beyond the schema by implying the role of these parameters in the broader tax calculation.

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?

Clear verb 'Calculate', specific resource 'US self-employment tax', and distinct aspects (QBI deduction, quarterly payments). Differentiates from siblings like calculate_freelancer_tax and calculate_quarterly_tax by specifying self-employment tax specifics and use of IRS brackets.

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 use for self-employment tax calculations, but does not explicitly state when to use it over alternatives like calculate_freelancer_tax or calculate_quarterly_tax. No exclusions or alternative recommendations are given.

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 of behavioral disclosure. The description mentions outputs (monthly payment, total interest, months saved) but doesn't disclose key behaviors: whether it assumes a fixed interest rate, whether it compounds monthly, whether extra payments are applied to principal, or what the default term is (though the schema hints at a default of 10 years). It also doesn't state whether the calculation is an estimate or exact, or any limitations. For a financial calculation tool, this is a significant gap.

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

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

The description is a single concise sentence that front-loads the core purpose ('Student loan payoff') and lists the key outputs. It's efficient with no wasted words. However, it could be slightly more structured by separating the purpose from the outputs, but it's still appropriately sized.

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

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

Given the tool's complexity (financial calculation with 4 parameters, no output schema, no annotations), the description is incomplete. It doesn't explain the calculation assumptions (e.g., fixed vs variable rate, compounding frequency, whether extra payments reduce principal), nor does it describe the return format. An agent would need to infer these details or call the tool to discover them. For a financial tool, this is a notable 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%, so the schema already documents all four parameters. The description adds context by mentioning 'extra payments' which maps to the extraPayment parameter, and 'months saved' implies the loanTermYears parameter. However, it doesn't add meaning beyond what the schema provides, such as clarifying that interestRate is an annual percentage or that loanAmount is in dollars. Baseline 3 is appropriate given full schema coverage.

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: 'Student loan payoff' with specific outputs (monthly payment, total interest, months saved with extra payments). It distinguishes itself from sibling calculators like calculate_car_loan and calculate_mortgage by explicitly naming student loans. However, it doesn't explicitly differentiate from other loan calculators beyond the domain, so it's clear but not fully differentiated.

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

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

The description implies usage context: it's for student loan payoff calculations, and the mention of 'extra payments' suggests a scenario where the user wants to compare payoff timelines. However, it doesn't explicitly state when to use this tool versus alternatives like calculate_mortgage or calculate_car_loan, nor does it provide exclusions or prerequisites. The context is implied but not 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 present, so the description carries the full disclosure burden. It conveys that results are estimates rather than guarantees and confines coverage to US MFN + Section 301 tariffs — genuine behavioral context. But it stays silent on whether duty rates are fetched live, how 'category' maps to HS codes internally, and how an optional tariffRate overrides built-in rates, which are useful behavioral traits for a calculator with no other 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?

Two short sentences, both load-bearing: the first states verb, resource, and method; the second states jurisdiction scope. No filler, no restatement of schema field names, and the essential purpose is front-loaded.

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 usefully names the expected outputs ('import duties and landed cost'), covering the return-value concept. Gaps remain: whether freight is required to produce landed cost (it is optional in the schema), how tariffRate and category interact, and behavior for categories outside US MFN/301 coverage. Adequate for a single-purpose calculator, but not 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 100%, so the baseline is 3. The description adds one meaningful link: 'by HS code category' clarifies that the weakly described 'category' parameter means an HS code category, which the schema ('Product category') alone does not convey. It also implies freight feeds into the landed-cost computation. It does not explain precedence between tariffRate and category, a minor residual 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 uses a specific verb ('Estimate') with a concrete resource ('import duties and landed cost') and a stated method ('by HS code category'). The 'US MFN + Section 301' clause gives precise jurisdiction scope and cleanly differentiates it from the many calculate_* siblings (tax, loans, ROI, reseller profit), none of which handle import duties. An agent can identify this tool without ambiguity.

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 scope line 'Covers US MFN + Section 301 tariffs' implies the tool is for US import estimates, which is an implied boundary. However, it never names an alternative or states when-not-to-use (e.g., non-US tariff regimes, or sales tax via get_sales_tax_rate). Selection logic is left mostly 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?

No annotations are provided, so the description carries the burden. It discloses that this is an estimate and not the IRS tracker, and gives the formula. It does not mention output sign conventions, tax year, or that results depend entirely on user-provided inputs.

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 no filler. The core purpose and formula are front-loaded, and the clarifying exclusion is placed second. 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?

For an 8-parameter calculator with no output schema, the description gives the essential formula, scope, and a key exclusion. It is slightly incomplete because it does not state the output sign convention or clarify behavior when optional state parameters are omitted, but it is sufficient for correct invocation.

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

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

Schema coverage is 100%, so the baseline is 3. The description adds meaningful parameter relationships by explaining 'tax owed minus withholding minus credits' and the federal/state scope, which helps an agent understand how grossIncome, federalWithheld, stateWithheld, and credits interact.

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 ('Estimate') and resource ('US tax refund or balance due'), and defines the calculation formula. It clearly distinguishes itself from the IRS refund tracker, making its 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?

It provides clear context: use before filing to estimate refund or balance due, and explicitly excludes the IRS refund tracker. However, it does not name sibling alternatives like calculate_income_tax or explain when to prefer those.

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

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

No annotations exist, so the description bears the full burden. It discloses the methodology basis ('Wayfair ruling') and that current thresholds are used, which tells the agent the result is rule-based and up to date. However, it does not describe the output form, the role of the two numeric inputs in the threshold check, or whether the tool is an estimate/legal advice, leaving meaningful behavioral gaps.

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

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

Three short sentences, with the main purpose first and the two supporting facts (Wayfair basis and threshold recency) each earning their place. No filler or repetition.

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 covers the core purpose and methodology but leaves notable context gaps: no output schema, no annotations, and no statement about how statesWithSales affects the result or what happens if only totalSales is provided. For a simple two-parameter tool this is adequate but not complete.

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

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

Schema description coverage is 100% for both totalSales and statesWithSales, so the schema already explains the parameters. The tool description only references 'thresholds' and does not add further meaning about the numeric inputs beyond what the schema provides, so the schema-heavy baseline of 3 applies.

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

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

Opens with a specific verb ('Check') and a concrete resource ('which US states you have economic nexus in'), then anchors it to 'sales tax collection', 'Wayfair ruling', and 'Latest CDN thresholds.' This clearly differentiates it from sibling rate-lookup tools like get_sales_tax_rate or payment tools like calculate_quarterly_tax.

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 supplies a clear use context: determining economic nexus obligations for sales tax. It does not explicitly list exclusions or alternatives, but the context is specific enough that an agent can select it over sibling tax-rate and filing tools.

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

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

No annotations are provided, so the description carries the full burden. It discloses the tool computes growth, tax drag, and gives a recommendation, and uses latest contribution limits. However, it doesn't disclose behavior like whether it accounts for employer match, whether recommendation is based on assumptions, how tax drag is modeled, or what happens with different tax rates. For a financial comparison tool with no annotations, more behavioral disclosure is needed.

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 key information: what is compared, time horizon, outputs, and a note on using latest limits. Efficient and front-loaded with the main purpose. Could be slightly more structured but very 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?

For a 6-parameter calculator with no output schema and no annotations, the description provides core purpose and outputs but misses notable context: how employer match is used (if at all), whether 401(k) and Roth IRA limits differ by year, what 'recommendation' means, and how tax rates interact. It's adequate for a basic calculator but has gaps for an agent to know edge cases.

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 schema already documents all parameters. The description adds context about the comparison scope (pre-tax vs post-tax, tax drag, contribution limits) that helps parameter intent. It doesn't add detail on specific parameters like years or annualReturn, but with full schema coverage baseline 3 is exceeded slightly by framing contribution and tax rates in the retirement comparison context.

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 compares 401(k) pre-tax vs Roth IRA post-tax, with a specific resource and focus (30-year growth, tax drag, recommendation). It's specific, but doesn't explicitly differentiate from siblings like compare_w2_vs_1099 or compare_llc_cost; however the resource is clear enough.

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 usage for retirement account comparison and mentions using latest CDN contribution limitsholidays. It doesn't explicitly state when to use this versus alternatives (like compare_compound_interest for generic growth, or other tax calculators). Context is implied but no exclusions or explicit alternative 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 burden of behavioral disclosure and does provide useful context: it reveals a two-step comparison logic, includes a price-verification date, and states the workload alignment between subscriptions and API baseline. However, it omits calculation assumptions, output format, currency, and how the 'winner' is determined beyond the implied cheapest cost.

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, leading with the core comparison action and then adding the API-pricing stage and data-recency note. It is slightly run-on, but every phrase contributes useful information with no tautology or fluff.

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 calculation tool with fully documented optional parameters, the description is largely complete: it names products, comparison frequency, workload inputs, and price freshness. The main gap is the absence of any return-value or output description, but given the schema's richness this is not a blocking omission.

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 documents all four parameters at 100% coverage, so the baseline is 3. The description adds minor semantic glue by mapping team size and usage intensity to the relevant parameters, but it does not meaningfully expand on what the parameter descriptions already say.

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 comparison action, enumerates the exact subscription products covered, and adds the secondary comparison against pay-as-you-go API pricing. This clearly distinguishes it from the many sibling calculation tools even without naming alternatives.

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 explicit guidance on when to choose this tool over close siblings like compare_llm_api_costs or compare_automation_platform_costs, and no exclusions or prerequisites are stated. The intended use can be inferred from the content, but the agent is not told how to route among 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?

With no annotations provided, the description must carry the full burden. It discloses the counting-model difference, which is a key behavioral nuance, but does not state whether this is a pure calculation, whether it accesses external pricing data, or what the return format is. It gives some transparency but leaves important operational aspects unspecified.

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 sentence that front-loads the core purpose and includes the key differentiator (counting-model difference). It is concise and efficient, though slightly verbose due to the parenthetical clarifications. 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?

Given no output schema and no annotations, the description should explain what the tool returns and any operational constraints. It does not describe the output format or whether it depends on external data, which is a gap for an agent deciding how to use the result. It covers the comparison logic well but leaves the output ambiguous.

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

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

Schema description coverage is 100%, so the schema already explains each parameter. The description adds context about workflow volume and the counting-model difference, which helps justify why stepsPerRun and runsPerMonth matter, but it doesn't go beyond the schema in a substantial way. 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?

The description clearly states the tool compares monthly costs on two specific platforms (Zapier and Make) for the same workflow volume, explicitly calling out the counting-model difference. This is a specific verb+resource that distinguishes it from other compare_* siblings like compare_llm_api_costs.

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 this tool (when comparing Zapier vs Make costs at a given volume) but does not explicitly mention alternatives or exclusions. However, the purpose is specific enough that an agent can infer usage without confusion.

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

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

No annotations are provided, so the description carries the behavioral burden. It discloses the data source (latest CDN state fees data) and the 5-year calculation horizon, adding useful context. However, it doesn't state whether the operation is read-only, whether it makes network calls, or how results are presented – leaving some behavioral uncertainty.

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 short sentences with no filler. The core purpose is front-loaded, and the data-source detail earns its place. Could be considered terse 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 tool is simple with two optional params and no output schema, so the description doesn't need to be extensive. Still, it lacks an explanation of the return format (e.g., a table of states vs a single-state number) and how 'state' alters the comparison, which an agent would need to set expectations. Given the low complexity, this is a minor but real 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?

Both parameters have schema descriptions (100% coverage), so the baseline is 3. The description reinforces the 'years' default by headline-ing 5-year total cost, but adds no new meaning for 'state' beyond the schema. It doesn't clarify the exact interaction between state and comparison output.

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: compares LLC formation and maintenance costs across US states. Clearly distinguishes from sibling comparison tools (401k, W2, LLM costs) by naming the exact domain. The 5-year total cost and data source reinforce purpose.

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

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

No explicit when-to-use or alternatives are mentioned. The domain is distinct among siblings, so usage is implied, but the description doesn't state when to prefer this over other comparison tools or whether to use it for single-state vs multi-state comparison. That inference is left to the agent.

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

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

With no annotations, the description carries the burden of explaining behavior. It discloses what the tool computes, that it ranks all 18 models, that it reports cheapest and most expensive options and cost spread, and that it filters based on whether models can fit the prompt. It could mention data-source assumptions or defaults, but the core behavior is well covered.

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

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

Two sentences deliver the core purpose, the workload formula, and the reported outputs with no filler. The ranking behavior is front-loaded and the context-window check is a valuable addition that 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?

The tool has no annotations and no output schema, so the description must cover enough for correct invocation. It explains inputs, ranking logic, and key outputs. Minor gaps remain around data-source recency, currency, and how optional parameters behave when omitted, but the essential context is present.

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

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

Schema description coverage is 100%, so the baseline is 3. The description adds meaning beyond the schema by explicitly defining the cost formula: inputTokensPerCall, outputTokensPerCall, and callsPerMonth combine to determine monthly cost, and minContextWindow relates to whether a prompt fits. This adds useful semantics beyond basic field descriptions.

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

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

The description opens with a specific action and resource: 'Rank 18 LLM models by the real monthly cost of a given workload,' using the formula input/output tokens per call × calls per month. It clearly distinguishes this from sibling tools like compare_ai_coding_tool_costs and compare_automation_platform_costs by targeting LLM model pricing.

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

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

The description gives clear context for when to use the tool: when comparing LLM models on cost for a specific workload and context-window fit. It doesn't explicitly name alternatives or exclusions, but the phrase 'LLM models' plus the detailed workload formula makes the intended use obvious relative to the financial and infrastructure 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 of behavioral disclosure. It reveals that the tool uses 'Latest CDN data' (implying up-to-date tax rates) and lists the tax components it considers, which adds some transparency. However, it does not state whether the operation is read-only, what the output structure looks like, what assumptions are made (e.g., income thresholds, deduction applicability), or any limitations. This is a moderate gap for a calculation tool.

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

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

The description is a single, efficient sentence that front-loads the primary action and then lists the key factors. It wastes no words and is immediately scannable. The use of a colon and comma-separated list is clear and structured.

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 calculation tool with 4 parameters and no output schema, the description covers the core purpose and main factors but omits important operational details: it does not describe the return value (e.g., a breakdown or a single number), does not mention any assumptions about tax years or income brackets, and does not clarify that it is US-specific (though state tax implies it). Given the complexity of tax calculations, an agent might need more guidance on what to expect from the output, so a 3 is warranted.

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 100% coverage, so all parameters (w2Salary, contractorRate, state, filingStatus) already have descriptions. The tool description adds context by mentioning tax components like state tax and standard deduction, which implicitly connects parameters to their role in the calculation. This is a marginal improvement over the schema, but not enough to raise above the baseline 3 for a well-covered schema.

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

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

The description uses a specific verb ('Compare') and names the exact resources ('W-2 salary vs 1099 contractor rate'), making the purpose unmistakable. It also lists the key factors considered (SE tax, FICA, standard deduction, state tax), which distinguishes it from sibling tools like calculate_se_tax or calculate_freelancer_tax that focus on single calculations.

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 implies when to use this tool: when an agent needs to compare take-home pay between W-2 and 1099 employment. It does not explicitly mention alternatives or exclusions, but the comparison focus is self-evident and the sibling list shows other tax tools are for different purposes. A 4 is appropriate because it is clear enough without explicit when-not 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 behavioral burden. It discloses a critical guarantee—'without changing how agents call them'—and states the return value ('compressed definitions plus exact token savings'). It does not detail error behavior or exact output formatting, but core side effects are 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?

Two sentences with no fluff: purpose first, result second. Every phrase earns its place and the description is easy to scan.

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 one-parameter, pure transformation tool with no output schema, the description covers what it does, why, and what it returns. The main gap is the unspecified exact structure of the compressed output and token savings, but it is sufficient for an agent to invoke and use the tool.

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

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

Schema description coverage is 100%, so the baseline is 3. The tool description adds context about compressing MCP definitions but no additional parameter-level meaning beyond the schema's clear description of 'definitions'.

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 ('Shrink'), a resource ('MCP tool descriptions and JSON schemas'), and a goal ('cut context cost'). It is clearly distinct from calculation/estimation siblings, but it does not explicitly differentiate itself from related tools like estimate_mcp_context_budget.

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 clear context for when to use the tool: when you want to reduce context cost of tool definitions. It does not mention exclusions or alternatives, but the purpose is specific enough that an agent can determine appropriate use.

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

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

With no annotations present, the description carries the behavioral transparency burden; it does disclose that the tool quantifies wasted quota and dollars, which is useful output behavior. However, it does not explicitly state that the operation is read-only, whether it only analyzes the supplied JSON locally, or what assumptions/limits apply to the calculation.

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 focused sentences with no filler; the core use case is front-loaded and the output is stated immediately. 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?

The description is sufficient for a simple analysis tool with a well-documented schema: it tells the agent what problem to solve and what the result will quantify. There is no output schema, so a bit more detail about the return shape could improve completeness, but the current level is adequate 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 100%, so the schema already documents all parameters; the description adds valuable context about why the workflow fields matter (polling vs webhook waste) but does not add specific parameter-level meaning beyond the schema. 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?

The description names a specific verb ('Find') and a specific resource: the hidden cost of polling where a webhook would do in no-code automation. It also states the measurable outcome ('wasted task/operation quota and monthly dollars'), so an agent understands what the tool accomplishes. It does not name or contrast a sibling tool, so it lacks full differentiation but is clearly not tautological.

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

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

The description clearly frames the intended scenario: no-code automation workflows with polling triggers where a webhook would be cheaper. This gives a clear usage context, but it does not explicitly state when not to use it or name alternatives such as compare_automation_platform_costs.

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 burden. It clearly states the action ('Paste your MCP config') and the return value ('per-server token cost, remaining budget, and ranked reduction advice'), making the tool's behavior transparent without needing side-effect warnings.

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, front-loaded with the main purpose and then the required action. Every clause adds value with no filler.

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

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

The description provides the input action serve, key inputs covered by schema, and a clear summary of return values despite no output schema. It is complete enough for an agent to select and invoke the tool correctly, though it could mention limitations or explicit alternatives.

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

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

Schema description coverage is 100%, so the schema already documents all parameters. The description adds no additional parameter-level semantics beyond what the schema provides, keeping it at 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 clearly states a specific verb and resource: estimating LLM context-window consumption from MCP servers and recommending which tool definitions to cut. It distinguishes itself from planning or compressing tools by emphasizing 'estimate' and 'cut first' as its outcome.

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 it: when you have an MCP config and want to estimate context budget consumption. However, it does not explicitly mention alternatives like plan_context_window_budget or compress_tool_definitions, nor does it provide 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 no annotations provided, the description carries the full burden. It adds meaningful behavioral information: the tool includes maintenance hours often overlooked and reports a 'true break-even volume.' However, it does not disclose assumptions, limitations, or how the estimate is computed beyond that, so the transparency is adequate but not rich.

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 no filler. The first sentence states the comparison and the key cost component, and the second states the output. Every word earns its place, and the informal 'people forget to cost' adds clarity rather than confusion.

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 simple calculator nature, full parameter schema coverage, and clear two-sentence purpose, the description is largely sufficient. It lacks an explicit return format or exclusions versus sibling tools, but for a tool with no output schema and no annotations, this is a minor gap rather than a blocking one.

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

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

Schema description coverage is 100%, so the baseline is 3. The description adds conceptual framing for maintenanceHoursPerMonth ('maintenance hours people forget to cost') and for the overall break-even result, but it does not substantially expand on parameter meaning beyond what the schema already states.

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

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

The description uses a specific verb ('Compare') and clearly identifies the resource ('paying hosted CI overage against running self-hosted runners'), plus the distinguishing factor of including maintenance hours. It is immediately distinguishable from siblings like calculate_break_even or calculate_github_actions_cost, which are more generic or focused only on cost, not break-even comparison.

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 frames the scenario: comparing hosted CI overage vs self-hosted runners and mentions the 'maintenance hours people forget to cost,' which signals when this tool is relevant. It does not explicitly name alternatives or state when not to use it, but the context is clear enough to guide selection against the sibling list.

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

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

With no annotations, the description must carry the behavioral burden. It discloses that the tool selects and returns relevant tools rather than executing them, and explains the intended client-side effect. However, it does not describe return format, side-effect guarantees, or any constraints like rate limits or query semantics beyond the basic routing 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?

Two sentences with the core purpose front-loaded in 'Semantic tool router' and an immediate elaboration. The reference to 'MCP optimisation literature' is slightly ornamental but does reinforce the meta-tool identity. No wasted words overall.

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 two-parameter tool without an output schema, the description gives enough context to understand the tool's role and input. The missing return-form detail is partially covered by the 'inject 3 schemas' phrase, which implies the return includes tool definitions. Slightly more explicit output behavior would push this to a 5.

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 description need not restate parameters. It does add context for 'query' (natural-language intent) but contributes no additional meaning for 'limit' beyond the schema's own default. The description's value here is marginal.

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 defines the tool as a 'semantic tool router' that takes a natural-language intent and returns the most relevant tools from the server. This specific verb-object pair ('return relevant tools') distinguishes it from the many domain-specific calculator/advisor siblings, and the meta-tool framing makes its role 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 states the context of use: when a client needs to reduce the number of tool schemas injected (from 27 to 3) by querying a natural-language intent. It does not explicitly list when not to use it or mention alternatives, but the use case is clear enough from the 'instead of 27' phrasing.

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 disclosure burden. 'Ready-to-paste' implies the output is a formatted config snippet, which is a useful behavioral hint. However, it does not disclose what happens with partial inputs (e.g., command vs url are both optional but typically one is needed), whether the tool validates configs, or what the output structure looks like 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?

Two sentences with the core purpose front-loaded in the first. The second sentence ('Config completeness decides whether developers can install your server at all') is a motivational hook that adds minor persuasive value but no operational detail. Efficient overall, with only slight 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?

For a 5-parameter generation tool with no annotations and no output schema, the description is moderately complete. It names the targets and output format ('ready-to-paste') but does not clarify which parameter combinations are valid (e.g., does a remote server need url, does a stdio server need command+args), nor what a typical generated config looks like. The absence of an output schema raises the burden on the description, which is only partially met.

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

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

Schema description coverage is 100%, so every parameter is already documented in the schema. The description adds the cross-cutting context of the four target clients but does not explain the semantic relationship between parameters (e.g., that command/args are for stdio servers while url is for remote/streamable-http). Baseline 3 is appropriate since the schema handles the heavy lifting.

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

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

The description states a specific verb ('Generate') plus a concrete resource ('ready-to-paste MCP server config') and enumerates the four target clients (Claude Desktop, Cursor, VS Code, Windsurf). It clearly differentiates from sibling tools like generate_mcp_server_card (which produces a server card, not client config) and audit_mcp_server_security.

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

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

The description gives no explicit guidance on when to use this tool versus alternatives. Among the many generation/validation siblings (generate_mcp_server_card, validate_mcp_server_card, score_mcp_server_trust), there is no routing logic or when-not-to-use statement. The second sentence about completeness is motivational, not directional.

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 purpose (discovery without connection) but not any side effects, such as whether it overwrites an existing file, requires network access, or validates inputs. There is no mention of the output format or any constraints on the generated JSON. This is thin for a generation tool.

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

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

The description is a single, front-loaded sentence with zero fluff. It states the action, the artifact, and the rationale efficiently, which is ideal for quick agent scanning.

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 7 parameters (2 required), no output schema, and no annotations, the description is underspecified. It does not explain the structure of the generated card (SEP-1649 standard), how the 'tools' parameter affects the summary, or any validation behavior. An agent would need to inspect the schema and possibly the standard to call it correctly. The presence of a sibling validate_mcp_server_card suggests a related workflow, but that is not mentioned.

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 all 7 parameters have descriptions in the schema. The tool description adds no additional parameter-level meaning beyond the schema. It does not explain how 'tools' should be structured or how 'transport' interacts with 'endpointUrl', but the baseline of 3 is appropriate given the complete schema coverage.

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 a specific verb ('Generate'), a concrete resource ('SEP-1649 MCP Server Card' at a well-known path), and the purpose ('so crawlers and registries can discover your server'). It distinguishes itself from siblings like validate_mcp_server_card and generate_mcp_client_config by focusing on the server-card artifact.

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 it (when you want your server discoverable) but does not explicitly contrast with alternatives or state exclusions. There is no mention of validate_mcp_server_card for post-generation validation or generate_mcp_client_config for client-side config, so an agent must infer the context.

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. It usefully discloses that the result combines base and estimated local rates and notes data freshness, but it does not clarify how the optional amount parameter influences behavior or what the output format is.

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 short sentences, each adding distinct information: scope, output composition, and data freshness. The main action is front-loaded and there is no filler.

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

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

For a simple two-parameter lookup with no output schema, the description is mostly complete: it covers scope, return composition, and data provenance. The main missing context is the role of the optional amount parameter, but this is a minor gap given the 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?

Schema description coverage is 100%, so both parameters are already documented. The description adds no additional meaning about how 'amount' is used or how the rate is computed, so the baseline score of 3 applies.

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

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

The description uses a specific verb+resource pair ('Get state sales tax rate') and defines the scope ('any US state') and the return composition ('base state rate + estimated local rate'). This makes it immediately distinguishable from the many calculate_* sibling tools and from check_economic_nexus.

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 intended use is implied: use this when a state sales tax rate is needed. However, it does not explicitly state when to prefer this tool over sibling alternatives, mention exclusions, or clarify how the optional amount affects selection.

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

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

With no annotations, the description must carry the burden of behavioral disclosure. It does reveal what the tool computes (per-window consumption, remaining space, fit). However, it doesn't state that this is a read-only estimation, how aggregate assumptions like avgTokensPerTool are used, or what the returned shape looks like.

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 filler; core behavior is front-loaded and the clarifying question adds value compactly. 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?

For a read-only planning/calculation tool, the description covers the main outputs and the motivating use case well. It is slightly thin on assumptions and return format, but the schema defaults and parameter documentation fill most 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?

The schema already documents all four parameters and the servers input shape with 100% coverage, so the description adds little concrete parameter meaning. It provides helpful framing ('tool definitions consume', 'left for conversation') but not enough to exceed the baseline for high schema coverage.

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 ('show') and resource (MCP server tool definitions against model context windows), and lists exact outputs: consumed tokens, remaining capacity, and fit. It also states a concrete user question it answers. However, it does not explicitly distinguish itself from similar siblings like plan_mcp_token_budget or estimate_mcp_context_budget.

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 motivating question 'how many servers can I attach on model X?' implies a clear use casechers. But the description gives no explicit guidance on when to use this tool versus alternatives, and it does not mention exclusions or sibling relationships.

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. It only hints at the output ('per-dimension cost split and a quota plan') but does not state whether the tool has side effects, requires specific permissions, or operates purely in-memory. For a planning/calculation tool, this is a notable gap.

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

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

The description is a single, focused sentence that front-loads the core purpose. It avoids fluff and is easy to parse. It could be slightly more informative, but it is concise and well-structured.

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 four parameters, no output schema, and no annotations, the description is too sparse. It fails to explain the relationship to sibling tools, the expected input format beyond the schema, or any usage constraints. An agent would need additional context to invoke it confidently.

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

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

Schema description coverage is 100%, so all parameters are documented in the schema. The description adds minimal extra meaning beyond restating the purpose; it does not elaborate on how parameters interact or provide examples. Baseline of 3 is appropriate given the schema handles semantics.

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: planning and attributing MCP token spend across agents, servers, and workflows. It uses a specific verb ('plan and attribute') and a clear resource ('MCP token spend'), and mentions the output. It doesn't explicitly differentiate from siblings like estimate_mcp_context_budget, but the focus on 'plan and attribute' is distinct enough to be clear.

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 provided on when to use this tool versus its siblings (e.g., estimate_mcp_context_budget, plan_context_window_budget). The description lacks any mention of alternatives, exclusions, or prerequisites. An agent would have no basis to choose this over similar cost-planning tools.

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

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

No annotations are provided, so the description carries the full burden of behavioral disclosure. It says the tool scores trustworthiness and asks the caller to supply known server facts, but it does not describe side effects, how partial information is handled, whether follow-up questions are asked, or what the returned report contains. With no output schema, this is a notable transparency gap.

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

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

The description is two short sentences with no filler. The core action ('Score an MCP server A–F'), the purpose, and the input expectation are front-loaded and each 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?

The description gives enough context to know the tool is a comparative trustworthiness scorer and that inputs are optional known facts, which is useful given all 8 parameters are optional. However, there is no output schema and the description does not describe what the returned score or report will contain or how an agent should act on an incomplete set of inputs.

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 covers 100% of parameters with individual descriptions, so the baseline is 3 even without parameter detail in the description. The description adds the useful context that all fields are optional pieces of knowledge ('Supply what you know about the server'), but adds no per-parameter meaning beyond the schema.

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

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

The description states a specific verb and resource: 'Score an MCP server A–F on trustworthiness and maintenance health.' It also gives a clear use context ('choose between four servers that all claim to do the same thing'). It does not explicitly distinguish itself from siblings like audit_mcp_server_security, so it stops short of a 5.

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

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

The phrase 'so you can choose between four servers that all claim to do the same thing' gives clear context for when to invoke this tool. It does not name alternative tools or list exclusions, but the intended selection scenario is reasonably 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 behavioral disclosure burden. It is transparent that the tool only analyzes and reports (no mutation implied), enumerates the exact areas checked (serverInfo, transport, capabilities, authentication, semver, URL, tools entries), and states the return type as a full error and warning list. This is strong coverage for a validation 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 tightly packed sentences: the first states purpose and timing, the second enumerates checks and output. Every clause adds operational value, and the most decision-relevant information ('before you publish') is front-loaded. No filler or redundant schema repetition.

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 single-parameter validator with no output schema, the description adequately covers input context, validation scope, and expected return (error and warning list). It could go slightly further by describing the structure of the error/warning list, but the agent has enough to select and invoke the tool correctly.

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

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

Schema coverage for the single 'card' parameter is 100%, listing accepted types and forms entrepreneurially. The description adds meaning by naming the fields and formats that get validated, which goes beyond the schema's generic 'server-card.json content' phrasing. This is above the baseline of 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?

Description uses a specific verb ('Validate') and resource ('MCP Server Card against SEP-1649'), and details the checks it performs (structure and format). It is clearly distinguished from siblings like generate_mcp_server_card, audit_mcp_server_security, and score_mcp_server_trust by focusing on spec compliance and pre-publication validation.

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 'before you publish it' gives a clear context for when this tool should be used, and the description's focus on missing/malformed fields distinguishes it from security audits or trust scoring. It does not explicitly name sibling alternatives or state when not to use it, but the usage window is clear.

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