FreeToolHub

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

With no annotations, the description carries the full burden and it does clarify that the tool produces 'recommendations' rather than directly modifying the portfolio. It does not explicitly state that it is non-mutating or what happens with incomplete input data, leaving some behavioral 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 two sentences with no excessive detail, and the motivational framing is brief. It front-loads the problem and then states the actionable outcome, making it 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?

There is no output schema, and the description only names the recommendation types (keep/merge/remove) without detailing the output structure or edge cases. It is adequate for guiding invocation but leaves questions about how incomplete tool data and merge recommendations are handled.

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 parameters. The description adds modest context by linking 'tool list and usage' to the tools parameter and referencing the target tool count guideline, but does not add meaningful syntax-level detail.

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 the specific action ('get keep / merge / remove recommendations') and the resource (tool portfolio) and adding the 10–15 tool guideline makes the outcome concrete. It is clear enough to distinguish from most siblings, though it does not explicitly name a sibling it is not.

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: when too many MCP tools exist and the agent needs pruning advice. However, it gives no explicit when-not-to-use guidance or alternatives, so an agent must infer the boundary against siblings like compress_tool_definitions.

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?

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 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 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 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 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 full burden. It adds a key behavioral guarantee ('without changing how agents call them') and specifies that compressed definitions plus exact token savings are returned. It could further state side-effect behavior, but for a pure compression/return operation the disclosure is reasonably complete.

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, dense sentence that front-loads the action and purpose, then adds the return value. There is no filler or repetition of schema information.

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

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

The tool is simple: one required parameter fully documented in the schema, and the description explains the output even without an output schema. Nothing an agent needs to invoke it correctly is missing.

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

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

Schema description coverage is 100%, so the schema already fully documents the single parameter. The tool description adds no additional parameter meaning beyond what the input schema provides, 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 uses a specific verb ('Shrink') with a clear resource ('MCP tool descriptions and JSON schemas') and the stated outcome ('cut context cost'). It also explicitly names what it returns, distinguishing it as a compression tool rather than a budget estimator or calculator.

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 conveys when to use the tool: when tool definitions and schemas need to be reduced to lower context cost. It does not explicitly name alternatives or exclusions, but the purpose is specific enough that an agent would not confuse it with the sibling budget/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?

With no annotations, the description carries the burden of behavioral disclosure. It clearly says the tool 'Quantifies' wasted quota and monthly dollars, which conveys a non-mutating analysis that returns a cost estimate. It could explicitly state it is read-only or requires no side effects, but the core behavior is 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 waste; the primary purpose is front-loaded, and the quantification detail follows immediately. Every word earns its place.

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

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

The schema fully documents both parameters, and the description explicitly states the tool's output (wasted task/operation quota and monthly dollars), compensating for the lack of an output schema. The definition is complete enough for an agent 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 is 100% with descriptive properties (e.g., platform values and the workflows JSON structure), so the baseline is 3. The description adds no additional meaning to the parameters; it focuses on the tool's purpose rather than parameter details.

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 ('Find') and resource ('most common hidden cost in no-code automation: using polling where a webhook would do'), and clarifies it quantifies wasted task/operation quota and monthly dollars. This clearly distinguishes it from sibling cost calculators like calculate_github_actions_cost or compare_automation_platform_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: this tool is for detecting polling-vs-webhook waste in no-code automation, which implies when an agent needs that specific analysis. It does not explicitly name alternatives or exclusions, so it misses a 5, but the context is strong.

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 itself. It discloses the return value format (per-server token cost, remaining budget, ranked reduction advice), which is useful, but does not mention side effects, privacy, or any estimation caveats. For a pure analysis tool this is adequate, though 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 fluff, purpose front-loaded, and the input instruction immediately after. Every clause adds information.

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

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

The description covers input and output categories, and the schema documents all parameters. However, with closely related sibling tools and no output schema, it would benefit from stating when to use this estimator versus the planning/budgeting siblings, so completeness is only adequate.

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

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

All three parameters are already documented in the schema, including defaults and accepted config forms, so the description adds little parameter-specific meaning. Baseline 3 applies because schema coverage is 100%.

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

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

States a specific verb ('Estimate'), a concrete resource ('LLM context window consumed by MCP servers'), and the actionable outcome (which tool definitions to cut). It is clear on its own, but does not explicitly differentiate from the closely named siblings plan_context_window_budget and plan_mcp_token_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?

Gives the input format ('Paste your MCP config') but no guidance on when to choose this tool over siblings like plan_context_window_budget or compress_tool_definitions. No exclusions or conditions are provided, so an agent has to infer usage from the name.

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

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

With 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?

No annotations exist, so the description carries the full burden. It states the output is 'ready-to-paste' and mentions config completeness, but does not disclose whether it validates input, how it handles conflicting command/url parameters, whether it returns all four client configs at once, or any side effects. 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?

Two sentences with no fluff. The first sentence front-loads the core purpose and target clients. The second sentence adds a motivational note about installability, which is somewhat non-operational but not harmful.

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 annotations and no output schema, the description leaves significant gaps: it doesn't explain the output format, whether both stdio and remote server types are supported in one call, how env and args are structured, or what 'completeness' requires. An agent would need to infer too much to invoke this correctly.

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

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

Schema coverage is 100%, so the schema already documents all five parameters. The description adds no parameter-specific meaning beyond 'one input', and the schema already conveys that command is for stdio and url for remote servers. Baseline 3 applies.

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

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

The description uses a specific verb ('Generate'), names the resource ('MCP server config'), and lists the exact target clients (Claude Desktop, Cursor, VS Code, Windsurf). This clearly differentiates it from siblings like generate_mcp_server_card, which produces a different 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?

No guidance on when to use this tool versus alternatives such as generate_mcp_server_card or validate_mcp_server_card. The description implies use for producing client configs but gives no exclusions, prerequisites, or decision criteria.

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 disclosure. It does reveal the output format and spec, but does not state whether the tool writes the card to a file, returns it as a string, or has any side effects. Nor does it mention behavior on missing required params. This is a moderate gap 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 sentence, front-loaded with the action and spec, and includes the key benefit for the user. No filler or redundant phrases. It 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 7-parameter tool with no output schema, the description explains the purpose but omits what the tool returns (the card JSON text?) and whether any param combinations are required (e.g., endpointUrl with transport). The schema covers field meanings, but the description leaves some usage ambiguity.

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% across all 7 parameters, and the description adds no additional parameter-level meaning. The baseline of 3 is appropriate because the schema already documents each field, but the description could have clarified relationships (e.g., endpointUrl relevance for different transports).

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: 'Generate a SEP-1649 MCP Server Card (/.well-known/mcp/server-card.json)'. It also explains the purpose (crawlers/registries can discover your server without connecting) and clearly distinguishes this from siblings like validate_mcp_server_card. An agent can immediately know what this tool produces.

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 (generating a server card for discovery) but does not explicitly mention when to use it instead of validate_mcp_server_card or generate_mcp_client_config. It gives context but no exclusions or alternatives are named, so the agent must infer 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 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 provided, the description carries the full transparency burden, and it does a reasonable job: it discloses that the tool computes tool-definition consumption, remaining room for conversation, and fit per context window. It does not spell out every calculation detail such as the exact definition of 'fits' or estimation assumptions beyond the schema defaults, but the core computational behavior is not misleading.

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

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

The description is concise, uses two purposeful sentences, and front-loads the input and expected output. The final quoted question helps an agent quickly map the tool to a user intent without any wasted text.

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

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

The description covers the inputs and high-level outputs but lacks an output schema and does not describe the exact result shape, labels, or how edge cases like missing tool counts are handled. For a tool in a family of close siblings, a bit more detail about return values and assumptions would make it fully self-sufficient.

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

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

Schema description coverage is 100%, so the parameters are already well documented and the baseline is 3. The description adds some semantic context by framing the computation as tool-definition consumption and conversation share, but it does not materially improve on the schema's parameter explanations.

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 verb ('show') and resource (context-window consumption for a set of MCP servers), and it explains the outputs across four named context windows and the fit question. However, it does not explicitly differentiate itself from closely related sibling tools like plan_mcp_token_budget or estimate_mcp_context_budget, so it stops short of a fully distinguishing definition.

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: given MCP servers and their tool counts, evaluate whether they fit within model context windows and how many servers can be attached. It does not explicitly state when to choose this tool over overlapping siblings, and it offers 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 carries the full burden. It discloses that the tool 'Outputs per-dimension cost split and a quota plan,' which reveals the primary behavior. However, it does not mention side effects (or lack thereof), whether it requires authentication, how defaults apply, or what the quota plan concretely contains beyond a vague label.

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 action and scope front-loaded, followed by the output. The clause 'something the protocol provides no native support for' adds useful motivation but is not strictly necessary; still, it is brief and 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 is moderately complex (4 parameters, 1 required) and has no output schema, so the description must explain what to expect. It names the outputs generically ('per-dimension cost split and a quota plan') but does not clarify what the quota plan includes, how dimensions map to outputs, or how optional pricing parameters affect results. This leaves room for ambiguity.

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 fully documents all four parameters. The description adds no parameter-level meaning beyond referencing the workload dimensions (agents, servers, workflows) already implied by the schema. Baseline 3 is appropriate since the schema does the heavy lifting.

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

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

The description states a specific verb ('Plan and attribute') and resource ('MCP token spend') with explicit scope ('across agents, servers and workflows'). It also names the key outputs ('per-dimension cost split and a quota plan'), making the tool's purpose unmistakable and distinct from sibling 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 MCP token budgeting and adds the context that 'the protocol provides no native support for' this, but it does not explicitly say when to use this tool over related siblings like estimate_mcp_context_budget or plan_context_window_budget. No alternatives or exclusions are named, so usage is only implied.

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

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

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?

With no annotations provided, the description carries the behavioral burden. It clearly explains what is checked (structure and format), lists the specific fields/areas examined, and states that it returns a full error and warning list. This is sufficient transparency for a read-only 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?

The description is two focused sentences with no filler. It front-loads the purpose, then lists the scope of checks and the return type, making every sentence informative.

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 one simple parameter and no output schema, the description adequately explains inputs, checks, and outputs. It could be more explicit about the exact return structure, but 'full error and warning list' is enough for an agent to invoke it correctly.

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

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

Schema coverage is 100%, and the schema already describes the single 'card' parameter as 'The server-card.json content to validate'. The description adds useful detail about what validation is performed, but the parameter itself needs no extra explanation.

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

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

The description states a specific verb ('Validate'), a specific resource ('MCP Server Card'), and a standard ('SEP-1649'). It clearly distinguishes itself from siblings like generate_mcp_server_card and audit_mcp_server_security by focusing on SEP-1649 compliance 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 description explicitly says to run this 'before you publish' the card, which gives clear usage context. It does not name alternatives or exclusion cases, but the context is strong enough that an agent would know when to use it.

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