FalaZuki Finance BR

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

With no annotations provided, the description carries the full behavioral disclosure burden. It does disclose the core behavior: it recommends investment types and returns ranked options with pros and cons. It does not mention whether the tool is purely informational, whether recommendations are guaranteed or risk-averse, or any disclaimers about financial advice. This 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?

The description is two compact sentences with no redundant wording. It front-loads the main purpose and input scope, then states the output format. Every phrase 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?

There is no output schema, so the description's statement that it returns 'opções rankeadas com prós e contras' is the only return-value guidance. This gives a general idea but omits the ranking criteria, what kinds of investment types may appear, and any behavioral caveats. The parameter side is well-covered by the schema, but the output side is only partially specified.

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 documents all five parameters. The description restates four of them (perfil, prazo, valor, objetivo) but adds no syntax or format details beyond the schema. One parameter, needs_liquidity, is not mentioned, but its schema entry with a default covers it. 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 uses a specific verb ('Recomenda') and clearly identifies the resource ('tipo de investimento') and the inputs that drive it (perfil, prazo, valor, objetivo). It also states the output form ('opções rankeadas com prós e contras'). It does not explicitly name sibling tools for differentiation, though the profile-based recommendation framing distinguishes it from pure calculation/compare 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 when to use the tool: when a user has a profile, term, amount, and objective and wants investment recommendations. However, it provides no explicit guidance about when not to use it, no mention of alternatives like compare_investments or calculate_investment_return, and no prerequisites beyond the listed inputs.

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 does not mention that the recommendation is advisory, what factors besides revenue and activity are considered (e.g., employees), or any limitations. The optional has_employees and employee_count parameters receive no mention, leaving their role in the recommendation opaque.

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

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

A single, well-formed sentence that front-loads the action and outcome, listing the regimes and the key inputs. There is no filler or redundant information, making it highly efficient.

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 the core purpose and inputs but, with no output schema and no annotations, it omits what the response will look like (e.g., just the regime name or a detailed comparison). The role of optional parameters and the advisory nature of the recommendation are also unstated, leaving moderate gaps for an agent invoking this tool.

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

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

Schema description coverage is 100%, setting a baseline of 3. The description adds context by naming 'faturamento e atividade' as the basis, which maps to monthly_revenue and activity. However, it does not clarify how the optional employee-related parameters factor into the recommendation; the schema descriptions are minimal as 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 uses a specific verb 'Recomenda' and a clear resource 'melhor regime tributário', naming the exact tax regimes (MEI, Simples Nacional, Lucro Presumido) that are compared. It clearly distinguishes itself from sibling calculate_* tools by focusing on choosing the best regime rather than computing a single tax value.

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 like calculate_simples_nacional, calculate_mei_tax, or compare_clt_vs_pj. The description implies use for regime selection but provides no exclusions, prerequisites, or routing hints.

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 and does disclose the calculation behavior: it computes discounts and embedded interest using TIR. It clearly frames the tool as an evaluative calculation. It could say more about expected output format or assumptions, but it goes well beyond a bare 'calculates debt'.

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 sentences: the first explains what the tool does, the second gives decision utility, and the third lists required parameters. It is tightly packed with meaningful content and no filler.

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

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

The description covers what is computed, the method (TIR), and the decision context, which is enough for an agent to invoke the tool correctly. There is no output schema, so a few words on the exact shape of the result would make it fully complete, but the current coverage is strong for a numeric calculator.

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 type, range, and meaning. The description adds only the instruction to use exactly these names, which is useful but not additional semantic depth. 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 states a specific verb ('Avalia'), a clear resource ('proposta de acordo de dívida'), and the exact outputs: real discount for cash and installment, and embedded interest via IRR. It also grounds the purpose with a realistic context (Serasa Limpa Nome), making it easy to distinguish from generic debt or loan 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 gives clear decision context: it is the tool to decide whether to save money, pay in installments, or seek cheaper credit. It does not explicitly name alternative tools or exclusions, so guidance on when not to use it is left implicit rather than explicit.

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

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

With no annotations, the description carries the full burden, and it delivers: it discloses the exact formula, the conversion factor, and the meaning of clock hours. It does not state the return format, but for a calculation tool the output (the additional amount in R$) is strongly implied by the formula and context.

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 all information front-loaded: the formula first, then parameter requirements. Every clause earns its place, and there is no redundant repetition of schema content.

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

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

Given three simple parameters, full schema coverage, and no output schema, the description is nearly complete: it states the calculation, parameters, optional values, and naming conventions. A small gap is that it does not explicitly say the result is the monthly additional value in R$, but this is easily inferred from the formula.

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

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

Schema description coverage is 100%, so the schema fully documents salary, monthly_hours, and night_clock_hours. The description adds the 1.14 conversion context and reinforces required/optional status, but does not add substantial meaning per parameter beyond what the schema already provides.

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

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

The description uses a specific verb ('Calcula') and resource ('adicional noturno urbano'), and goes further by specifying the exact calculation components: 20% over daytime wage plus the reduced night-hour effect (52min30s → 1.14 paid hours). This is easily distinguishable from sibling calculators like calculate_overtime or calculate_hourly_wage.

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 establishes the use case (urban night shift additional, 22h-5h) and tells the agent which parameters are required versus optional, plus to use exact English names. It does not name alternatives or exclusion conditions, but the specialized scope makes when-to-use unambiguous.

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

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

It discloses the main calculation behavior: CLT adds the 13th salary and vacation bonus, making the year 13.33 salaries. However, it does not explain how months_worked affects the calculation or what exactly the tool returns, which leaves some behavior to inference.

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: it starts with the core calculation, then the CLT formula, then the use case and parameter guidance. Every sentence adds necessary information without padding.

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 three parameters the description is mostly sufficient, but the handling of months_worked is ambiguous and there is no explicit statement about the output format or whether the result is gross. These gaps matter because the schema alone does not provide them.

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

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

The schema already documents all parameters with 100% coverage. The description repeats the required/optional status and parameter names, but adds no new semantic 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 clearly states the verb and resource: it calculates how much a monthly salary yields in a year. It also explains the CLT-specific formula (13.33 salaries) and the comparison context, making it distinguishable from siblings like calculate_thirteenth_salary or calculate_vacation_pay.

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 a clear use case: comparing a CLT proposal with a PJ proposal. It does not explicitly mention alternatives or when not to use the tool, but the intended scenario is well 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, the description carries the behavioral disclosure burden. It explains the calculation model (amount received today against annual withdrawals, by IRR) and the decision context, going well beyond the tool name. It does not specify output format or caveats like assumptions of constant annual parcels, but as a pure calculator this is reasonably 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?

Three sentences with no filler. The core purpose is front-loaded, followed by usage context and parameter guidance. 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 calculator with three fully documented parameters and no output schema, the description covers the purpose, the financial scenario, and the required inputs. The main gap is not describing the output format in detail, but the term 'taxa de juros' and the comparison context make the expected result clear enough.

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

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

Schema coverage is 100%, so the baseline is 3. The description adds meaningful value by explicitly listing the required parameters and instructing the agent to use exactly these names in English — a critical cross-lingual detail not present in the schema.

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

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

The description clearly states the specific purpose: reveal the embedded interest rate in an FGTS birthday-withdrawal advance offer using IRR. It identifies the resource (antecipação do saque-aniversário do FGTS) and the calculation method (TIR), which distinguishes it from siblings like calculate_fgts, calculate_cet, and compare_loans.

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 usage context: 'É a conta pra comparar a antecipação com um crédito comum antes de assinar.' This tells an agent when to invoke it, though it does not explicitly name alternatives or state when not to use it.

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

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

With no annotations, the description carries the full behavioral burden. It explains the calculation inputs and the rule that sales don't affect the average, and that fees enter the average. However, it does not disclose the output format, rounding behavior, or edge cases such as inconsistent current_quantity/current_average_price values, so some behavioral uncertainty remains.

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 well-structured: it starts with the purpose, then the calculation inputs, then usage notes, then parameter requirements. Every sentence earns its place and there is no redundant filler.

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

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

Given the moderate complexity and full schema coverage, the description covers the essential context: when to use it, how to chain multiple purchases, the sale caveat, and which parameters matter. The only notable gap is the absence of any description of the return value or format, especially since no output schema is provided.

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 value by grouping parameters into required vs optional and instructing the agent to use exact English names, but it does not add new meaning beyond the schema's parameter 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 states a specific verb ('Calcula') and resource: the new average price of stocks or FIIs after a purchase. It clearly distinguishes itself from the many sibling financial calculators by specifying the exact scenario (post-purchase average price) and even notes that sales do not change the average price.

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

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

It provides clear when-to-use guidance: after a purchase, and for multiple purchases it instructs chaining calls. It also gives a when-not case ('Venda não altera o preço médio'). It does not explicitly name an alternative tool, but the context is specific enough that an agent can select it correctly.

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 does disclose the calculation rule and three outcomes: the proportional notice days, the indemnified amount, and the employee discount. However, it does not describe return format, rounding behavior, or assumptions, and there is no output schema to fill that 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 and front-loaded, with the formula stated first and no filler. The final instruction about exact parameter names is useful 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?

For a two-parameter calculator, the description is reasonably complete: it gives the formula, names both parameters, and enumerates the three outputs. It lacks return-shape details and explicit sibling differentiation, but it is sufficient for correct invocation in most 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 description coverage is 100%, so the baseline is 3. The description adds only a reminder of mandatory parameter names and the instruction to use them in English, plus a loose link to the formula. It adds little semantic value 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 uses a specific verb and resource: 'Calcula o aviso prévio proporcional' and even states the formula ('30 dias + 3 por ano completo de casa (máximo 90)'). It is clear, but it does not explicitly distinguish itself from overlapping siblings such as calculate_severance or check_severance, so it falls just 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 description implies when to use it by naming the domain and parameters, but it gives no explicit when-to-use conditions, no exclusions, and no alternatives. Given the many sibling labor-related calculators, explicit routing guidance would have been valuable.

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 states what the tool returns (units, revenue, contribution margin) and explains the concept of contribution margin. It does not mention side effects (likely none for a pure calculation) or edge cases, but it adequately covers the behavioral expectation that this is a read-only computation that produces specific numeric outputs.

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, with the purpose front-loaded, followed by output details and parameter list. Every sentence earns its place, and there is no redundant filler. It is well-structured for quick parsing by an agent.

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

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

Given there is no output schema, the description adequately explains what the tool returns and what the output means. It defines the contribution margin and mentions both required and optional inputs. It does not detail edge cases or formula assumptions, but for a straightforward calculator with well-documented schema parameters, the description is sufficiently complete for correct invocation.

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

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

Schema description coverage is 100%, so each parameter already has a semantic description. The tool description merely restates which parameters are required/optional and stresses using exact English names, which adds no new meaning beyond the schema. It does not deepen understanding of parameter relationships or constraints, so a baseline 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 clearly states the specific purpose: calculating the break-even point in terms of units and monthly revenue, plus the contribution margin. It names the exact output metrics and distinguishes itself from the many sibling financial calculators by focusing on break-even analysis. The verb 'Calcula' plus the resource 'ponto de equilíbrio de um negócio' makes it 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 implicitly indicates when to use this tool (when break-even analysis is needed) and explains what it computes. It does not explicitly name alternatives or state when not to use it, but the niche purpose is clear enough for an agent to select it appropriately among the many calculate_* tools. This meets the 'clear context, no exclusions' bar.

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?

Sem anotações, a descrição assume o papel de informar o comportamento: define a regra 50/30/20, a entrada (renda líquida) e as categorias resultantes. Não detalha o formato exato do retorno, mas o comportamento central de cálculo fica claro.

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?

Duas frases curtas e objetivas: a primeira informa o propósito e a regra, a segunda aponta o parâmetro obrigatório e o uso exato do nome. Não há redundância ou conteúdo irrelevante.

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?

Para um cálculo simples com um único parâmetro bem documentado no schema, a descrição fornece a regra, os insumos e as categorias de saída. A ausência de detalhes sobre o formato do retorno é uma lacuna menor, mas não impede o agente de invocar corretamente.

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?

O schema já cobre 100% do único parâmetro, com descrição, tipo e restrição exclusiva de mínimo > 0. A descrição apenas repete a obrigatoriedade e o nome do parâmetro, sem acrescentar novo significado semântico além do 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?

A descrição usa verbo específico ('Calcula') e recurso claro ('orçamento pela regra 50/30/20'), detalhando as categorias e a base de cálculo. Isso diferencia a ferramenta de todos os irmãos de cálculo financeiro, que tratam de outras finalidades.

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?

Há instrução direta de que net_income é obrigatório e que os nomes devem ser usados exatamente como em inglês. Porém, não há orientação explícita sobre quando escolher esta ferramenta em vez de alternativas como calculate_savings_return ou compare_investments; o contexto de uso é apenas implícito.

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 disclosure burden. It does disclose the key behavioral traits: the calculation includes all listed cost components, is bounded by an income ratio cap, and returns two values. It does not mention assumptions or default behaviors beyond what the schema shows, but for a calculator the core behavior is transparent; no contradiction.

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: purpose+output first, then parameter list. It is front-loaded and compact, though the explicit parameter list duplicates schema information. No filler or marketing language.

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

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

For an 8-parameter calculator with no output schema, the description explains the calculation inputs, cost scope, and output, but it lacks a comparison with the closely related sibling calculate_car_ownership_cost and does not specify the return format in detail (e.g., units, failure case). Overall it is adequate but not complete for disambiguation.

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?

Input schema already covers all eight parameters with descriptions (100% coverage), so the baseline is 3. The description merely lists which parameters are required vs optional and insists on English naming, adding no semantic information 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 opens with a specific verb and resource ('Calcula que preço de carro cabe numa renda') and clarifies it accounts for total ownership cost (prestação, IPVA, seguro, manutenção, combustível) and returns the affordable price and remaining installment. This distinguishes it from plain financing calculators and from the sibling calculate_car_ownership_cost, though it does not name that tool explicitly.

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

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

The description gives no guidance on when to prefer this tool over alternatives such as calculate_car_ownership_cost or calculate_financing. Usage is only implied by the stated purpose, and the only explicit instruction (use exactly these English parameter names) is about parameter usage, not tool 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 burden. It states it is a calculation ('Calcula'), which implies a read-only operation, but it does not explicitly disclose that it has no side effects, does not require external data, or describe the output format. It does add the parameter naming directive, which is helpful, but it lacks explicit behavioral transparency expected for a mutation-free 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 concise, with the primary purpose front-loaded, followed by parameter lists and a directive. It contains no fluff and every sentence contributes value. It could be slightly more compact by merging the parameter list into the schema, but it remains efficient and well-structured.

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

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

For a 5-parameter calculation tool with no output schema, the description explains the calculation and the comparison with anticipation, which covers the core purpose. It does not detail the return value or edge cases (e.g., what happens with defaults), but the schema provides defaults for optional parameters. The description is adequate for an agent to call the tool correctly, though not exhaustive.

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 with descriptions. The description lists required and optional parameter names but adds no extra semantic meaning beyond what the schema provides. It does instruct to use exact English names, which is a minor addition, but essentially the description does not compensate beyond the baseline for 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 specific verb 'Calcula' (calculates) with a clear resource: the net amount from a card machine sale and its effective monthly cost, plus a comparison with anticipation cost. This is precise and distinct from sibling calculate_* tools, making selection unambiguous.

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

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

The description clearly implies when to use this tool: whenever a user wants to evaluate the true cost of a card machine transaction. It does not explicitly name alternatives or exclusions, but the purpose is so specific that an agent can infer the use case. A brief mention of alternatives would improve the score.

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 usefully discloses that reference_date recomputes with the historical tax table ('refazer um mês passado com a tabela da época') and that deductions include book expenses, dependents, alimony and INSS. But it does not specify return format/units or mention how the progressive table applies to net taxable income, 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?

Three dense sentences in Portuguese: purpose+examples, historical behavior, and required/optional param names. No filler—each sentence earns its place, and the most distinctive information (DARF 0190, income types) 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?

The description explains the calculation domain, the eligible income, the deduction items, the historical-table behavior, and the exact parameter names/requirements — a strong set for a 6-param calculator with no output schema. The only notable omission is an explicit statement of what the function returns (e.g., tax amount in R$), so it falls just short of 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 coverage is 100% and each parameter has its own description, so the baseline is 3. The description adds a meta-instruction to use the exact English parameter names and marks monthly_income as required and the rest optional, which is helpful but largely restates the schema's required array and property names.

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 'Calcula o carnê-leão do mês (DARF 0190)' — a specific verb, tax form, and period — and enumerates the exact income types it applies to ('aluguel direto do inquilino, honorários de autônomo, rendimentos do exterior'). This level of specificity distinguishes it from generic DARF and RPA 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?

It provides clear applicability context by listing the income sources and deductible items, so an agent can choose it for monthly carnê-leão obligations. However, it never names alternatives or states when not to use it (e.g., annual IR via simulate_income_tax), so it earns 4 rather than 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?

There are no annotations, so the description carries the full burden. It discloses the tool's scope and inputs, but does not state the output format (e.g., a single monthly total vs. a breakdown) nor the assumptions for IPVA, depreciation, maintenance, or insurance rates. These are meaningful gaps 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 two sentences: the first front-loads the core purpose and components, the second covers required/optional parameters and a naming caveat. It is efficient and free of fluff, though the parameter enumeration is partially redundant with the schema.

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 a 9-parameter calculator with no annotations and no output schema, the description adequately conveys what it computes and which inputs are required. However, it does not explain the output format or the underlying cost model assumptions, so an agent may still be unsure what a successful invocation returns or how inputs influence results.

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

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

The schema already describes all 9 parameters with 100% coverage, so the description adds little beyond restating names and required/optional status. The instruction to use exactly these names in English is a useful minor guard, but no deeper semantics are provided 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 begins with a clear verb and object: 'Calcula o custo mensal real de ter um carro' (calculates the real monthly cost of owning a car), followed by a concrete list of cost components. It is specific and unambiguous, but it does not explicitly name sibling tools like calculate_car_affordability or compare_fuel to highlight differentiation.

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 usage is implied through the purpose statement, and the parameter list gives some context. However, there is no explicit 'use this when' / 'use that instead' guidance, no mention of alternatives, and no exclusions, so an agent gets little help choosing among the many sibling calculator 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 and it does disclose notable behavior: results use 'IR regressivo descontado', compare with 'a poupança', and use today's 'Banco Central' CDI. It also clarifies that cdi_percent can represent partial or full CDI, but it does not describe exact return values.

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: outcome first, options second, parameter usage third. Each sentence adds distinct guidance, and there is no filler or unnecessary restatement.

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 three-parameter calculator, the description names required and optional parameters, gives an example, and flags behavioral details such as IR and savings comparison. The absence of an output schema makes the lack of explicit return-format detail a minor gap, but it would not prevent correct invocation.

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

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

Schema coverage is 100%, so the description adds only modest value beyond the schema: an example like '102% de um CDB', a note that cdi_percent is optional, and an instruction to use exact English parameter names. Most parameter meaning already lives in the input 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 opens with a specific verb and resource: 'Calcula quanto rende um valor no CDI de hoje (Banco Central) por um prazo em meses'. It further distinguishes the tool by mentioning regressive IR and savings comparison, making it clearly distinct from generic savings/investment 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?

It states the calculation context and required parameters, but it does not explicitly say when to choose this tool over siblings like calculate_savings_return or compare_with_cdb. The intended use can be inferred from the CDI-specific wording, so guidance is implied rather than explicit.

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

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

No annotations are provided, so the description carries the behavioral disclosure burden. It compensates well by explaining the calculation method (embedded interest derived via TIR) and the key modeling assumption that fees and insurance deducted from the released amount are incorporated into the rate. A minor gap is the lack of output format or units, 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?

Three sentences, each earning its place: the first states the purpose and inputs, the second explains the TIR methodology and fee handling, and the third gives usage and naming guidance. It is front-loaded, compact, and free of 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?

Inputs are fully defined by the schema and the method is clearly explained, but there is no output schema and the description does not state what the tool returns (e.g., CET as a percentage, decimal, annual rate). For a calculation tool, that return-format gap leaves the description slightly 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 net_received, installments, and installment_value. The description adds a useful naming instruction ('Use exatamente estes nomes, em inglês') and restates the meaning of net_received, but does not meaningfully extend the parameter semantics beyond the schema.

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

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

The description clearly states the tool's purpose: calculate the CET (Custo Efetivo Total) of a credit proposal from the borrower's perspective, using net amount received, number of installments, and installment value. This is a specific verb plus resource, and the mention of TIR and fee treatment distinguishes it from other calculate_* 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 provides clear usage context: it explains the borrower-facing inputs and even instructs the agent to call the tool twice to compare proposals. It does not explicitly name alternative tools or exclusion conditions, but the context is clear enough for correct selection among many financial calculators.

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

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

With no annotations, the description carries the full burden of behavioral disclosure. It explains the calculation mechanics in detail: IPCA is applied multiplicatively, the legal rate is additive, interest is simple and applied to the already-updated value, and it returns the complete calculation memory. This goes well beyond a generic 'update value' statement.

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

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

The description is dense but every sentence carries essential information: legal basis, calculation method, scope exclusions, return value, and parameter naming requirements. The front-loaded action and legal framing allow quick understanding, with details and warnings following in a logical sequence.

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 moderate complexity and absence of an output schema, the description covers the required parameters, calculation order, legal references, and exclusions, and it states the return value ('memória de cálculo completa'). It does not specify rounding or formatting details, but for this tool the information provided is sufficient for correct invocation.

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

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

Schema coverage is 100%, so the baseline is 3, but the description adds value by explicitly listing the required parameters, insisting on exact English names, and reinforcing the multiplicative vs. additive roles of the two rate parameters. This helps an agent map the parameters to the Formula described.

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

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

The description states the specific action ('Atualiza um valor') and the precise legal regime (Lei 14.905/2024, CC arts. 389 and 406), making it clear this is a civil monetary update calculator. It distinguishes itself from sibling calculators by specifying the civil regime and explicitly excluding labor, tax, and public treasury debts.

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 for civil regime updates under the named law and effective date. It also provides an explicit when-not ('não presume aplicação a débitos trabalhistas, tributários ou contra a Fazenda Pública'), though it does not name alternative tools for those 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?

There are no annotations, so the description carries the full burden. It explains the conceptual behavior of the calculation (prepayment vs redemption timing) but does not disclose what the output represents, its units, or any assumptions beyond the same-rate CDB. This leaves important 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 three sentences with no fluff. It front-loads the calculation's purpose, then gives the key condition, then parameter usage. Every sentence earns its place.

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

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

The description explains the underlying concept and constraints well, but with no output schema and no annotations, it should clarify what the result means (e.g., cost in R$, percentage, annualized). That missing information is significant for a specialized financial calculator.

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%, setting a baseline of 3. The description adds value by explicitly labeling required vs optional parameters and insisting on exact English parameter names, which prevents an agent from translating or renaming them. This is practical guidance 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 verb 'Calcula' and the specific resource: the cost of come-cotas (semiannual IR prepayment on open funds) compared with a CDB of the same rate. It is specific enough to identify the tool's purpose, though it does not explicitly differentiate it from the sibling compare_with_cdb.

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

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

It provides clear context for when the calculation is valid, including the minimum 25-month term and the condition that only the timing effect remains. It distinguishes required vs optional parameters but does not explicitly state when to prefer this tool over alternatives.

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

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

With no annotations, the description carries the burden of behavioral disclosure. It does reveal the formula M = C × (1+i)^n and the existence of periodic deposits, which is helpful. However, it does not specify how deposits are timed, how annual_deposit_growth is applied, what the output shape is, or other edge-case behaviors.

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 sentences with no filler: the main action comes first, then the formula, then a concise parameter list and naming rule. Every sentence earns its place and answers a practical question.

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 output schema and no annotations, yet the description never states what the tool returns (e.g., final amount, JSON object, projection). It also leaves deposit timing and annual growth behavior unexplained. For a financial calculator with 5 parameters, these gaps make the definition incomplete for reliable 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 coverage is 100%, so baseline is 3. The description adds value by explicitly enumerating required vs optional parameters and instructing the agent to 'Use exatamente estes nomes, em inglês', guarding against translation errors. It still does not elaborate on the meaning of annual_deposit_growth beyond what the schema provides.

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

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

The description opens with 'Calcula juros compostos com aportes mensais', naming a specific verb, calculation type, and differentiator (monthly deposits). The formula and the listed parameters make clear it is compound interest with periodic contributions, which separates it from siblings like calculate_simple_interest and other 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 states the required and optional parameters, but it does not explicitly say when to prefer this tool over alternatives or when not to use it. Usage context is implied by the phrase 'juros compostos com aportes mensais' rather than stated directly.

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 disclosure burden. It explains what the tool computes but does not disclose assumptions, formulas, or what happens if optional parameters are omitted. This is adequate but leaves 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?

Two sentences with no filler: the first defines purpose and outputs, the second gives parameter names and usage guidance. 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 tool with 5 parameters, no annotations, and no output schema, the description covers the main outputs and input expectations reasonably well. It does not detail return format or behavioral caveats, but the high schema coverage compensates partially.

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 value by explicitly separating required from optional parameters and instructing the agent to use exact English parameter names, which helps avoid translation or naming mistakes.

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

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

Description states the tool simulates consórcio and enumerates concrete outputs: monthly installment, total cost with admin fee, and comparison with financing. This is precise and distinguishes it from finance-only siblings like calculate_financing.

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 through 'Simula consórcio' and lists required/optional parameters, but it does not explicitly say when to choose this over calculate_financing or compare_loans, nor does it provide exclusions. The routing is left to inference.

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

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

No annotations are provided, so the description carries this burden. It discloses the calculation/comparison behavior and the output concept ('Mostra o custo real de pagar o mínimo'), and 'Calcula' implies a read-only operation. It does not describe input assumptions or edge cases, but nothing contradicts the schema.

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

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

Three short sentences cover function, output, and parameter requirements with no filler. 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 calculator with no output schema and no annotations, the description gives essential call context: purpose, required/optional parameters, and the English-naming caution. It lacks an explicit output structure and edge-case guidance, so it is not a 5, but it is sufficient for correct invocation.

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

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

Schema coverage is 100%, with type, range, and default descriptions for all five parameters. The description adds a line telling the agent exactly which names are required vs optional and to use English parameter names, which is genuinely useful for this Portuguese-labeled tool.

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 ('Calcula'), a precise resource ('juros do crédito rotativo do cartão'), and a comparison target ('parcelamento da fatura'). This clearly distinguishes it from generic sibling calculators such as calculate_installment and compare_loans.

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 first sentence establishes a clear scenario: comparing revolving credit interest against invoice installment. It does not explicitly name alternatives or exclusions, but the context is clear enough for an agent to select it appropriately.

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 a key behavior beyond a simple read: 'Estima a base do FGTS quando não informada' (estimates the FGTS base when not supplied). It also transparently explains the calculation logic for each path, including which components are included. No contradictions exist since there are no annotations. It could have mentioned output format, but the estimation behavior is the main non-obvious trait and is clearly stated.

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: three sentences plus a parameter list. The main purpose and scenario breakdown are front-loaded, followed by parameter guidance. The list of required/optional parameters partially repeats the schema, but the explicit naming instruction earns its place for agent usability. Slight redundancy keeps it from a 5, but it is 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 calculator tool with 5 parameters and no output schema, the description is largely sufficient. It covers the three scenarios, the estimation behavior, and required/optional parameters. Combined with 100% schema coverage, an agent can invoke it correctly. Missing details like output format or whether all three results are returned at once are minor given the phrase 'nos três caminhos' implies all paths are calculated. It is complete enough for its complexity.

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

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

Schema coverage is 100%, so the schema already documents all parameter meanings. The description adds value by reiterating which parameters are required vs optional and clarifying that fgts_deposits_base is the base for the fine, but this largely duplicates schema descriptions like 'Omitido, estimamos 8% × salário × meses'. The instruction to use exact English names is helpful but not semantic enrichment 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 uses a specific verb ('Calcula') and resource ('quanto custa demitir um funcionário CLT') and enumerates the three distinct dismissal paths (sem justa causa, acordo mútuo, pedido de demissão). This clearly distinguishes it from sibling tools like calculate_severance or calculate_fgts by specifying exact scenarios and calculation components (40% FGTS fine, 20% fine, proportional amounts).

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 implicitly defines when to use this tool: for any CLT dismissal cost calculation covering the three named paths. It provides clear context about scope (CLT employees, three termination types) but does not explicitly mention alternative tools or when not to use it. The scenario breakdown gives enough context for selecting it, though it stops short of naming sibling exclusions.

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

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

With no annotations provided, the description carries the full behavioral burden and does substantial work: it discloses tax rates, the sales exemption threshold, IRRF offset, and loss compensation by modality. It does not mention output format or edge cases, but the key computational 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?

The description is two sentences with no fluff. The core calculation is front-loaded, and the compact parameter enumeration plus the explicit 'use exactly these names' instruction 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 sufficiently covers the calculation domain, tax rules, and all 8 optional input names for a tool with no output schema. The main gap is that it does not describe what the return value looks like, but the tool's purpose makes the output largely self-evident.

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 each parameter's meaning. The description adds value by listing all parameter names and insisting they be used exactly in English, but it does not add deeper semantic details 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 ('Calcula') and a precise resource: the monthly DARF of variable income for individuals. It further disambiguates by enumerating the exact modalities (swing trade, day-trade, FIIs) and their respective rates, making it clearly distinct from generic 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 gives clear context on when to use the tool: for monthly variable-income DARF calculation with specific rules such as the R$ 20k exemption and IRRF compensation. However, it does not explicitly state when not to use it or point to an alternative, 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 provided, so the description carries the full burden of behavioral disclosure. It says the tool 'calcula' and 'compara', but it does not describe the return format, whether it assumes a certain payment schedule, any limitations, or side effects. For a calculator with no output schema, this is a significant 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 brief and front-loaded with the core functionality, followed by parameter instructions. It contains no fluff, but the sentence 'Parâmetros obrigatórios: debts. Opcionais: extra_payment.' largely duplicates the schema's required list. The added instruction to use exact English names earns some value, but the redundancy 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?

The tool has two parameters and a complete schema, but there is no output schema and the description does not explain what the comparison result looks like. An agent would not know whether the tool returns monthly payment plans, total interest savings, payoff timelines, or a simple recommendation. This missing return-value context is a critical gap 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 description coverage is 100%, so the baseline is 3. The description adds a useful instruction to use exact English parameter names and identifies which parameter is required vs optional, but it does not add semantic meaning beyond what the schema already provides. The core meanings of 'debts' and 'extra_payment' are already fully documented in the schema.

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

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

The description clearly states a specific verb and resource: it calculates a debt payoff plan using two distinct methods (avalanche and snowball) and compares them. It also names the required and optional parameters, leaving no ambiguity about what the tool does. It stands apart from the many sibling calculators by explicitly identifying the comparison behavior.

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 the user wants to compare avalanche vs snowball debt payoff strategies. However, it does not explicitly state when not to use it or which sibling tools (e.g., compare_loans) might be more appropriate for other debt comparisons. The guidance is limited to parameter usage, not situational selection.

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

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

With no annotations, the description carries the behavioral burden and covers key traits: it discounts weekends and all national/banking holidays, applies the 'start excludes, end includes' convention, and works for any year. It does not describe the exact return shape or behavior when conflicting parameters are provided, 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?

The description is compact, front-loaded with the core purpose, and every sentence contributes either behavioral detail or parameter routing. No filler or repeated schema content.

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

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

All invocation-critical details are present: modes of operation, holiday handling, day-count convention, and parameter requirements. The only gap is that the description does not explicitly state the response format (count vs date), though the tool's name and wording make it strongly inferable.

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 each parameter, but the description adds value by marking start_date as mandatory, grouping end_date vs add_days by use case, and instructing the agent to use the exact English parameter names.

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 two precise operations: counting business days between dates and projecting a deadline of N business days. It clearly identifies the domain (weekends plus all national and banking holidays) and distinguishes itself from generic date/calculation 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?

It explicitly states which parameters are mandatory or optional and associates end_date with counting and add_days with projecting, so an agent knows how to select the right mode. It does not name alternatives or give exclusion criteria, which prevents 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 provided, so the description carries the full burden of behavioral disclosure. It only restates the calculation modes and parameter presence; it does not describe the return shape, behavior when both or neither optional parameter is supplied, rounding, or error handling. With no output schema, these are meaningful gaps.

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

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

The description is short, front-loaded with the core function, and contains no filler. The parameter summary and 'use exactly these names' reminder are slightly redundant with the schema, but they are concise and serve as useful guardrails.

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 three-parameter calculator, the essential invocation context is present. However, without an output schema, the description omits the return format and edge-case behavior such as supplying both optional parameters or neither, leaving some uncertainty for the agent.

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 and the exclusivity between final_price and discount_percent. The description adds only a redundant required/optional summary and the instruction to use exact English names, which does not meaningfully improve on 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 opens with 'Calcula desconto' and immediately clarifies the two supported directions: final price from a percentage, or percentage from a final price. This makes the tool's specific function unmistakable and distinguishes it from the many sibling calculate_* tools.

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

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

It clearly states that original_price is required and discount_percent/final_price are optional, and it frames the two main usage scenarios. It does not name alternative tools or explicit exclusion conditions, but the intended use context is clear enough for 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 burden of behavioral disclosure. It transparently explains the calculation logic (income divided by yield, current portfolio income, and accumulation time), which is the core behavior. However, it does not mention output format, limitations, or edge cases like zero dividend yield, so it's not fully exhaustive.

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, purposeful sentence that states the primary function first, then lists required and optional parameters. It is concise and well-ordered, though the opening sentence is a bit long and could be divided for even better readability.

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

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

Given there is no output schema and five parameters, the description explains the core formula but does not specify the return format or how results are presented. It also doesn't address potential division by zero if dividend_yield is zero, although the schema's minimum of 0.5 provides some implicit protection. Overall, it covers the essential logic but lacks some completeness for edge cases and output structure.

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

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

The schema already describes all five parameters with 100% coverage, so the description adds limited extra meaning. It does note that monthly_income is required and instructs the use of English parameter names, which is helpful, but it doesn't enrich understanding of each parameter beyond the schema's own 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 function: calculating the wealth needed to live off dividends, and breaks down the calculation (monthly income divided by dividend yield, current income, and time to goal). This specific verb-resource pairing distinguishes it from siblings like calculate_dividend_yield, which focuses on yield rather than the goal amount.

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 specifies required and optional parameters but does not explicitly compare with alternatives such as calculate_financial_independence or calculate_retirement. The purpose implies when to use it, but there's no when-not guidance or named sibling alternatives, so it remains at the 'implied usage' level.

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 explains that the tool computes required investment for a target monthly dividend income, which is useful. However, it does not disclose calculation assumptions, output format, or limitations such as whether the annual yield is applied directly without monthly compounding.

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

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

The description is compact and front-loaded: the core purpose appears in the first sentence, followed by required/optional parameters and a naming instruction. Every sentence contributes necessary information 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 calculator tool, the description combined with the fully-covered schema is mostly complete for invocation. The main gap is the absence of any statement about what the result represents or how it is returned, since there is no output schema to fill that 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?

The input schema already provides 100% parameter descriptions and defaults, so the description adds little semantic value beyond restating required vs optional parameters. The note to use exact English names is a minor practical addition but does not deepen understanding of any 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 clearly states the function: 'quanto precisa investir pra receber X por mês em dividendos de ações ou FIIs' — a specific goal of computing required investment for a target monthly dividend income. It is clear but does not explicitly differentiate itself from near-sibling tools such as calculate_dividend_income_goal.

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 through the stated scenario, and it lists required vs optional parameters, including the instruction to use exact English parameter names. However, it offers no explicit guidance on when to choose this tool over alternatives like calculate_dividend_income_goal or calculate_investment_return.

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 clarifies that this is a calculation tool based on expenses and profile and notes the required versus optional parameters, but it does not disclose underlying assumptions (e.g., how profile maps to target months, whether monthly_return compounds) or what the return payload contains.

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 with the tool's purpose, followed by parameter requirements. The explicit reminder about using English parameter names is useful and earns its place, though listing all optional parameters partly duplicates the schema.

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 the core purpose and identifies required/optional inputs, which is reasonably complete for a simple calculator with no output schema. However, it omits important details such as the units for the 'time' output and the profile-based multiplier logic, so an agent could not fully anticipate the computed result without invoking the tool.

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

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

Schema description coverage is 100%, so the schema already fully documents each parameter. The description adds value by naming the required and optional parameters and by telling the agent to use exact English names, but it does not add deeper semantic 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 clearly states a specific verb ('Calcula'), a resource ('reserva de emergência'), and the computed outputs (ideal value and time to build). It distinguishes the tool from financial-independence or investment-return calculators by its explicit emergency-fund focus, though it does not name sibling alternatives explicitly.

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

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

The description implies when to use the tool—when an emergency fund value or funding timeline is needed—by specifying inputs like monthly expenses and profile. However, it gives no explicit guidance about when not to use it or which sibling tool might be more appropriate for related scenarios.

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 disclosure burden. It does state the included cost components and the parameter names, but it does not disclose whether the output is monthly or annual, whether employee-side deductions (INSS, IRRF) are excluded, or how defaults affect the result. This is adequate but sparse for a financial 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 compact: the first sentence states the purpose and cost components, and the second covers required/optional parameters plus a usage caution. It is front-loaded and contains no filler, although listing parameter names that already appear in the input schema is slightly redundant.

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 a complex financial calculation, the description should state whether the returned cost is monthly or annual and what aggregate the agent should present to the user. It also does not clarify what happens when optional parameters are omitted, leaving a critical interpretation gap for such an involved calculation.

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 with types, defaults, ranges, and regime-specific rules. The description only repeats the parameter names and adds a syntactic caution to use exact names, adding no semantic meaning beyond what the schema already provides.

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

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

The description states a specific verb ('Calcula'), a clear resource ('custo total de um funcionário CLT para a empresa'), and enumerates the cost components (encargos, FGTS, 13º, férias, provisões). This makes it easy to distinguish from sibling calculators like calculate_net_salary or calculate_hourly_wage, which target the employee side rather than the employer-side total cost.

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 about when to choose this tool over sibling calculators such as calculate_net_salary, calculate_annual_salary, or compare_clt_vs_pj. The phrase 'para a empresa' implies employer-side cost, but the description never states a decision rule, alternative, or exclusion, so an agent must infer the appropriate usage 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?

No annotations are provided, so the description bears the full burden of behavioral disclosure. It states the calculation inputs and outputs, but does not disclose any rounding behavior, units handling beyond kWh, order of operations, edge cases (e.g., zero watts), or whether the calculation assumes a standard month length. There is no mention of what happens with invalid inputs or how results are returned.

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. The first sentence front-loads the purpose and scope, and the second provides essential invocation details. Every word earns its place with no redundancy.

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

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

For a simple calculation tool with two top-level parameters and no output schema, the description covers the inputs and outputs adequately. It specifies the required parameters and their units, which is sufficient for an agent to invoke it correctly. Minor gaps like explicit formula assumptions (e.g., monthly = 30 days) are not critical given the low complexity.

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

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

Schema coverage is 100%: the input schema fully describes both parameters, including required fields within the appliances array and valid ranges for watts and hours_per_day. The description merely repeats the parameter names without adding semantic meaning beyond what the schema provides, 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 precise verb ('calcula'), a specific resource ('consumo de energia de uma lista de aparelhos'), and the calculated outputs (kWh, monthly and annual cost). It clearly differentiates from the many sibling calculate_* tools by naming the exact input domain (watts and hours per day).

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 names the two required parameters (appliances, price_per_kwh) and instructs the agent to use exactly these English names, which is helpful for correct invocation. However, it does not provide when-to-use vs. alternative tools or exclusion conditions, though the specificity of the purpose makes alternatives unlikely.

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 disclosure burden. It states that the calculation uses compound equivalence, also outputs the simple-multiplication result to expose the error, and requires exact English parameter names. It does not detail the response format or rounding behavior, but the core behavior of this pure calculator 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?

The description is compact at three sentences, front-loads the main action and example, then adds the comparison-output behavior and parameter-name reminder. The required-parameter list is slightly redundant with the schema, but the exact-name warning 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 supplies enums and the rate unit, and the description adds the formula, a worked example, and the fact that the response also exposes the simple-multiplication comparison. Since there is no output schema, a more explicit return-shape statement would help, but the definition is sufficient for a simple calculator invocation.

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

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

Schema coverage is 100%, so the schema already documents rate units and from/to enums. The description reinforces that rate, from, and to are mandatory and instructs the agent to use exactly those English names, an invocation cue rather than additional semantic meaning.

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

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

The description opens with a specific verb and resource: 'Converte uma taxa de juros de um período para outro', and specifies the method as compound equivalence with a concrete example (1.5% a.m. → 19.56% a.a.). This clearly distinguishes the tool from the many sibling calculators by defining its exact conversion scope.

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

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

The description makes the intended use clear: convert interest rates between periods by compound equivalence, and it contrasts with simple multiplication by showing what 'multiplicação simples' would produce. It does not explicitly name sibling alternatives or exclusion conditions, but the contextual guidance 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 provided, the description carries the transparency burden. It makes the read-only, computational nature clear ('Calcula') and discloses exactly what results the tool produces, including the annex and cost scenarios. It omits assumptions or error behavior, but for a pure calculation tool this is reasonably 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 purposeful sentences: the first captures the core computation and outputs, the second states the required parameters and naming constraint. No filler or redundancy.

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

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

For a two-parameter calculator with no output schema, the description provides enough context about inputs and the main returned insights (annex, effective rates, monthly cost). It could add precise output formatting or assumptions, but an agent can reasonably select and invoke it.

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

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

Schema description coverage is 100%, and the schema already defines both parameters with units and meanings. The description reinforces that both are required and insists on exact English names, but adds little semantic information 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 opens with a specific verb and resource ('Calcula o Fator R do Simples Nacional') and enumerates distinct outputs: resulting annex (III or V), effective rates in both scenarios, and monthly cost of being in the wrong annex. This clearly differentiates it from sibling calculators like calculate_simples_nacional even without naming them.

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 through the subject matter (Fator R) and explicitly lists required parameter names, but it does not state when to choose this tool over siblings or provide exclusion criteria. The guidance is inferable, 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?

With no annotations provided, the description carries the full burden. It discloses currency ('Atualizado 2026') and enumerates computed components, which is useful. Still, it does not mention assumptions (e.g., 8% contribution rate), limitations, or whether results are estimates, leaving the behavior only partly transparent.

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

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

The description is compact and front-loaded, with no filler. Each sentence earns its place: what is calculated, the 2026 update, required/optional parameters, and the naming caution.

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 3-parameter calculator with no output schema, the description lists the expected outputs and parameter requirements, which is decent. But it omits relevant boundary conditions, assumptions about FGTS rules, and any pointer to related tools, leaving some context gaps.

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

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

Schema description coverage is 100%, so the schema already fully documents salary, months_worked, and include_anniversary_withdrawal. The description reinforces required/optional status and naming conventions but adds little semantic 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 uses a specific verb ('Calcula') with a clear resource (FGTS) and enumerates the exact outputs: saldo, rendimento, saque-aniversário, and multa rescisória de 40%. This level of specificity distinguishes it from other calculate_* siblings, even without naming them.

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 states which parameters are required versus optional and insists on exact English names, which helps invocation. However, it does not guide the agent on when to choose this tool over closely related siblings like calculate_antecipacao_fgts or calculate_custo_demissao; selection context is only implied.

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

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

With no annotations provided, the description carries the full burden of behavioral disclosure. It discloses the core method (4% rule or custom withdrawal rate), which is meaningful, but it does not explain how current_savings and monthly_investment affect the result, what the output represents, or any assumptions such as inflation or real returns.

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: two sentences that front-load the purpose, then list the required and optional parameters. Every sentence contributes operational value and there is no redundant wording.

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

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

For a calculator with 5 parameters and no output schema, the description is adequate for selecting the tool and knowing the main inputs. However, it does not state the return format, whether the result is a single target amount, or how optional inputs like current_savings and monthly_investment alter the calculation, which leaves some ambiguity for an agent with no output schema to rely on.

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 in the schema. The description adds value beyond the schema by clearly grouping required versus optional parameters and warning the agent to use the exact English field names, which is useful given the Portuguese-language description.

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: it calculates the amount you need to accumulate to live off investment income, using the 4% rule or a custom withdrawal rate. It is clear and distinct in intent, but it does not name or distinguish itself from closely related siblings such as calculate_retirement, calculate_first_million, or can_i_quit_job.

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 the user asks about financial independence based on expenses and a withdrawal rate. It also gives operational guidance by listing required and optional parameters and stressing the exact English parameter names. However, it provides no explicit when-not-to-use guidance or alternatives among the many sibling financial calculators.

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

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

No annotations are provided, so the description must carry the behavioral disclosure burden. It discloses the three key outputs and the two supported systems, but it does not clarify behavioral details such as whether the down payment reduces the financed principal, the exact return shape, or what costs are excluded (e.g., taxes/fees).

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

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

The description is three short, purposeful sentences. It front-loads the function, then lists required/optional parameters, and ends with a naming reminder. Every sentence earns its place with no waste.

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

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

With no output schema, the description appropriately names the outputs an agent can expect. Given the rich parameter schema, the only notable omissions are how down_payment interacts with property_value in the calculation and the exact structure of the returned result.

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

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

Schema description coverage is 100%, so all five parameters already have meaningful descriptions. The tool description only restates which parameters are required/optional and emphasizes using exact English names, which adds no semantic value beyond the schema's existing definitions and examples.

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

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

The description opens with a specific verb and resource: 'Calcula financiamento imobiliário SAC ou Price' and then lists concrete outputs (parcelas, juros totais, valor total pago). This clearly separates it from sibling calculators like calculate_installment or compare_loans by restricting scope to real-estate financing with two explicit amortization systems.

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

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

Usage is implied through the purpose statement, but there is no explicit guidance on when to choose this tool over related siblings such as compare_loans or calculate_installment. The description does provide useful parameter-level guidance (required vs optional, exact names), but it does not state 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 burden of behavioral disclosure. It does disclose the calculation behavior, the real-rate assumption, and the parameter categories, but it does not describe the output structure or edge-case behavior (e.g., zero contribution, zero return, or how the 10/20/30-year results are returned together).

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 compact sentences with no filler. The main purpose is front-loaded, followed by the parameter contract. Every sentence earns its place.

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

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

The tool has moderate complexity (4 params, no output schema) and many siblings. The description covers the scenario, calculations, required/optional parameters, and naming convention, which is enough to invoke it correctly. However, it leaves the exact output shape unspecified, which would be helpful given the multi-part calculation.

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%, giving a solid schema baseline of 3. The description adds value by explicitly grouping required vs optional parameters and instructing to use the exact English parameter names, which is useful for an agent that might otherwise localize or reorder the arguments.

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

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

The description uses a specific verb ('Calcula') and a clear resource: how long a monthly contribution takes to reach R$ 1 million, how much came from interest, and the required contribution for 10/20/30 years. This clearly differentiates the tool from investment siblings like calculate_compound_interest or calculate_retirement by its unique goal-based horizon output.

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 this when the user has a monthly contribution and wants to know time-to-goal, interest share, or needed contribution for fixed horizons. It does not explicitly name alternatives or say when not to use it, so it falls 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?

Sem anotações, a descrição carrega o peso da transparência e faz isso bem: revela as regras de cálculo (alíquotas progressivas 15% a 22,5%, isenção do único imóvel até R$ 440 mil, isenção por reinvestimento em 180 dias, redução da Lei 7.713 e fatores FR1/FR2). Isso informa o agente sobre o comportamento substancial da ferramenta, ainda que não descreva o formato exato da resposta.

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 descrição é longa, mas concentra informações úteis em duas frases: a primeira define o propósito e as regras de cálculo, a segunda orienta sobre parâmetros. Embora repita parcialmente a existência dos parâmetros já presentes no schema, a instrução final sobre nomes exatos agrega valor.

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?

Para uma ferramenta complexa com 9 parâmetros e sem output schema, a descrição cobre os principais elementos de negócio, isenções e parâmetros obrigatórios/opcionais. Faltam apenas detalhes como tratamento de entradas inválidas ou formato do retorno, mas o núcleo para chamar e entender o comportamento está presente.

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?

A cobertura do schema é 100%, então o baseline é 3. A descrição lista os parâmetros obrigatórios e opcionais e instrui 'Use exatamente estes nomes, em inglês', o que ajuda na chamada, mas não adiciona significado semântico além do que já está documentado nas descrições do 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?

A descrição começa com verbo específico e recurso preciso: 'Calcula o imposto sobre o ganho de capital na venda de imóvel (DARF 4600)'. Os detalhes de alíquotas, isenções e fatores FR1/FR2 deixam claro que este não é um calculador genérico de DARF ou de imposto de renda, distinguindo-o dos muitos irmãos 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?

O contexto de uso fica implícito pelos detalhes do imposto sobre ganho de capital imobiliário e pela enumeração de parâmetros obrigatórios e opcionais. Porém, a descrição não diz explicitamente quando usar esta ferramenta em vez de alternativas próximas, como calculate_darf ou calculate_imposto_*.

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 clearly discloses the core behavior: reverse calculation from net to gross while discounting INSS and IRRF. Minor gaps remain around rounding, cap limits, and handling of infeasible inputs, but the main computational 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?

The description is short and front-loaded: first the core purpose, then the sibling distinction and use cases, then the required/optional parameters. Every sentence adds value 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 calculator with a complete parameter schema, the description covers purpose, usage, sibling distinction, and parameter names. The main gap is that there is no explicit statement about the return/output format, and edge cases such as impossible net targets are not mentioned, but the tool is still easy to invoke correctly.

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

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

Schema coverage is 100%, so the baseline is 3. The description usefully restates required vs optional parameters and insists on exact English names, but it adds no semantic meaning beyond what the schema already provides for types, defaults, bounds, or date format.

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 ('Calcula') and names the resource: gross salary needed to achieve a target net salary after INSS and IRRF. It also explicitly says 'É o inverso do calculate_net_salary', which clearly differentiates it from the most closely related sibling tool.

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

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

The description names the alternative tool directly and gives concrete scenarios: negotiating a proposal ('quero R$ 5.000 na mão') and telling an employer how much to register in the work card. This gives an agent clear when-to-use guidance without ambiguity.

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

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

With no annotations, the description carries the full burden. It discloses the calculation methodology (44h weekly = 220h monthly CLT divisor) and the behavioral adjustment logic (discounting commute time and expenses that exist only because of work). It doesn't mention rounding or exact output structure, but for a pure calculation tool, this is adequate.

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, purposeful sentences. The core calculation and its variants are front-loaded, followed by parameter guidance. There is no filler or repetition of schema details.

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 low-complexity: 4 scalar parameters, no nested objects, no output schema. The description names all parameters, requiredness, and the two outputs (legal hourly value and real hourly value). It does not explicitly state output units or rounding, but these are reasonably implied by the salary and hours context.

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

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

Schema coverage is 100%, so the baseline is 3. The description names the required and optional parameters and reinforces the exact English names, but it adds no deeper semantics beyond what the schema already provides for each field.

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: it calculates the hourly wage using the CLT divisor and also computes a 'real' hourly value by discounting commute time and work-related costs. This clearly distinguishes it from the many calculate_* siblings by naming the exact calculation method and the adjusted output.

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 lists required and optional parameters and instructs the agent to use exact English names, which is clear operational guidance. It does not name alternative sibling tools or exclusion scenarios, but the intended use-case—hourly wage with commuting/cost adjustments—is clear enough from context.

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

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

With no annotations provided, the description carries the behavioral burden and mostly meets it: it discloses the tax rates (20% up to US$50, 60% with US$20 discount above), the 17% ICMS 'por dentro', and the Central Bank exchange rate conversion. It does not state the output format, but the calculation behavior is clearly transparent.

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

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

The description is dense but well-organized: purpose and rates are front-loaded, then required and optional parameters. Each sentence carries useful information, though the rule details could be more structured for easier parsing.

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 tax calculation rules are fully explained, but there is no output schema and the description does not state what the tool returns (e.g., tax amount in BRL). Edge cases like values over US$3,000 or invalid inputs are also unaddressed, leaving minor gaps for an agent.

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 restates which parameters are required vs optional and advises using exact English names, but it adds no new semantic meaning beyond what the schema already documents for each field.

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 ('Calcula o imposto de compra internacional') and gives concrete examples (Shein, AliExpress, Amazon). It distinguishes itself from sibling calculators by focusing on import tax rules, so an agent can tell it apart from other calculate_* tools.

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

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

It provides clear context for when to use the tool: international purchases under Remessa Conforme, with the relevant tax brackets. It does not name alternatives or explicitly state when-not-to-use, but the domain is sufficiently constrained to guide selection.

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

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

With no annotations, the description carries the behavioral burden. It goes beyond a tautology by disclosing the calculation basis (15% on net annual gains above the IRPF exemption) and the legal foundation. It stops short of describing the return contract, but the core behavior is well disclosed.

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

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

Two dense sentences with the key formula front-loaded and parameter instructions after; no filler or redundant explanation.

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

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

For a deterministic calculator with two scalar inputs, the description plus schema is sufficient to select and invoke correctly. The only mild omission is the explicit output shape or zero-loss behavior, but no output schema exists and the computed value is strongly implied.

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 already have full Portuguese schema descriptions with units (R$), so the description adds limited semantic value. It reinforces that the names must be used exactly and that they are mandatory, but this largely duplicates the schema's required array.

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 ('Calcula'), names the resource ('imposto sobre prêmios de apostas esportivas e bets'), and even states the rate and legal basis (Lei 14.790). This clearly distinguishes it from the many other calculate_* tax 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?

It clearly identifies the intended context — annual betting/gambling prize taxation — and explicitly designates the two required parameters. It does not name alternatives or exclusions, so it falls short of full when/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 full responsibility, and it discloses substantive behavior: R$ 35k exemption for Brazil custody, progressive rates above it, DARF 4600, and the Lei 14.754 15% annual-adjustment regime with no exemption for foreign-held crypto.

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

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

The description is front-loaded with the primary verb and object, then compacts the key rules into a colon-delimited list and three short parameter sentences. No filler or repeated schema content.

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

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

For a complex tax calculator with no annotations and no output schema, the description supplies the regimes, threshold, and parameter mapping needed to invoke it. The only notable gap is that it never states the return contract explicitly (e.g., computed DARF amount or tax value), so the agent must infer the output.

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

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

The schema already covers all three parameters at 100%, so the baseline is 3; the description adds a useful guard by naming required and optional parameters and insisting on exact English names ('Use exatamente estes nomes, em inglês'). It does not add new semantic detail beyond the schema, hence not a 5.

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 the exact operation ('Calcula o imposto sobre ganhos com cripto') and scopes it with three tax regimes, so an agent can distinguish it from generic tools like calculate_darf or calculate_imposto_apostas without opening the schema.

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

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

The opening clause gives clear selection context: use for crypto capital-gains tax, with monthly-sales threshold and foreign-exchange special regime. It does not explicitly name sibling alternatives or state when not to use it, so it misses the top score.

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

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

With no annotations provided, the description carries the full burden, and it does disclose the two distinct behaviors: 10% withholding over R$ 50k/month and the annual minimum taxation rule for income over R$ 600k/year. It does not describe the output format or what happens when annual_income is omitted, but the core calculation 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?

The description is compact and front-loaded: the first sentence identifies the purpose and law, the second covers the two calculation rules, and the final sentence clarifies parameters. Every sentence earns its place 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?

Given no output schema and no annotations, the description covers the legal basis, thresholds, required vs optional parameters, and parameter names—enough to invoke the tool correctly. The main missing piece is the return semantics, such as whether the result is a single tax amount, a breakdown, or zero when thresholds are not met.

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

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

Schema description coverage is 100%, so the input schema already explains both parameters well. The description adds the explicit instruction to use the exact English parameter names, which is helpful, but it does not meaningfully deepen the conceptual meaning of monthly_dividends or annual_income 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 begins with a specific verb and resource: 'Calcula o imposto sobre dividendos a partir de 2026 (Lei 15.270)'. It goes beyond a generic label by naming the legal rule and both calculation thresholds, which clearly distinguishes it from dividend-yield, IRPF, and other tax 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 gives clear context for when to use the tool: for dividend tax under Lei 15.270, covering the R$ 50k monthly withholding trigger and the R$ 600k annual minimum-tax rule. It does not explicitly mention alternatives or state when not to use it, but the legal and threshold context is strong enough to guide 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?

Sem annotations, a descrição assume o peso de explicar o comportamento e o faz parcialmente: afirma que corrige pela inflação e mostra equivalência/poder de compra. No entanto, não detalha como direction altera o cálculo, se o retorno é um valor ou ambos, nem o comportamento do default de inflação.

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?

Duas frases curtas, com o propósito principal na primeira linha e instruções de parâmetros na segunda. Não há ruído ou repetição desnecessária; a estrutura é eficiente e de leitura imediata.

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?

Para uma calculadora simples, a descrição é suficiente para um agente entender o objetivo, mas a ausência de output schema e de detalhes sobre o que exatamente é retornado (apenas o valor corrigido, a diferença, ou ambos) deixa lacunas. A interação entre direction, annual_inflation e o resultado também não é explicitada.

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?

Como o schema já cobre 100% dos parâmetros com descrições, o baseline é 3. A descrição reforça os nomes exatos e obrigatoriedade, mas não acrescenta significado semântico relevante além do que o input schema já informa.

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?

A descrição usa verbo específico ('Corrige um valor pela inflação'), recurso claro (valor monetário) e índice definido (IPCA), deixando evidente a finalidade. Porém, não diferencia este tool de irmãos próximos como calculate_ipca_plus ou calculate_raise_vs_inflation, o que impede nota máxima.

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?

Não há orientação sobre quando usar este tool em vez de alternativas semelhantes, nem menção a exclusões ou pré-requisitos de contexto. A única instrução de uso se limita a repetir parâmetros obrigatórios/opcionais, que já estão no schema.

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 discloses rates (20%, 11%, 5%), the retirement implications per plan, and that the output includes the GPS code. It does not cover every edge case, but for a calculation tool this is solid coverage.

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

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

The description is compact and front-loaded: the core purpose and rates come first, followed by output detail and parameter guidance. Every sentence earns its place without redundancy.

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

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

Given no output schema and no annotations, the description covers the essential calculation logic, plan options, output hint (GPS code), and parameter requirements. Combined with the rich parameter schema, the agent has enough information to 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%, so the baseline is 3. The description adds value by identifying both parameters as optional and by stressing the exact English names to use, which prevents locale-related invocation mistakes.

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: 'Calcula o INSS mensal do autônomo/contribuinte individual' and enumerates the three plan types with their rates and retirement implications. This clearly distinguishes it from related siblings like get_inss_table or calculate_mei_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 gives clear invocation context by naming the optional parameters and instructing the agent to 'Use exatamente estes nomes, em inglês.' It does not explicitly name alternatives or exclusions, but the specificity of the tool's purpose makes the appropriate use case evident.

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 behavioral disclosure burden. It discloses the calculation model (Price system, fixed installments) but does not mention return format, rounding behavior, or edge cases. This is a minimum-viable disclosure for a pure calculator and contains no contradiction.

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 carry all the essential information: what the tool calculates, the calculation method, and the required parameter names. Every sentence earns its place, and the core function 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?

Given that there is no output schema, the description could have been more explicit about return format or rounding. However, the fixed-installment Price definition plus the fully documented parameters is sufficient for an agent to invoke the tool correctly in a typical financing calculation scenario.

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 the three parameters. The description adds value by explicitly listing the required parameter names and instructing the agent to use exactly these English names, which prevents naming and localization mistakes.

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 specific verb 'Calcula' and identifies the exact resource: financiamento/empréstimo installments via the Price system with fixed parcels. This clearly distinguishes it from siblings like calculate_financing and calculate_compound_interest, which cover other financing or interest 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 establishes the intended context: loan/financing calculations under the Price system with fixed installments, and states that all three parameters are mandatory. It does not explicitly name alternative tools or provide when-not-to-use conditions, but the intended usage is clear enough.

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

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

With no annotations, the description carries the full burden and does disclose core behavior: it simulates fixed income returns, calculates regressive income tax, and compares against poupança. However, it omits assumptions, output format, limitations, and the fact that LCA is not actually supported by the schema enum.

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, front-loaded with the tool's purpose, and contains no filler. The instruction to use exact English parameter names earns its place, though the unsupported LCA mention slightly reduces accuracy.

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

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

There is no output schema or annotations, so the agent needs more context about return values, assumptions, and how the result is presented. The description also fails to route the agent away from overlapping sibling tools and leaves a misleading LCA claim unresolved.

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 well. The description reinforces that the four parameters are mandatory and should be used with exact English names, which is mildly useful, but it adds no deeper semantics and does not resolve the LCA/enum mismatch.

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 ('Simula rendimento de renda fixa no Brasil'), enumerates the investment types, and adds behavior details like IR regressivo and comparison with poupança. However, it does not explicitly differentiate this tool from overlapping siblings such as calculate_lci_lca, calculate_tesouro_selic, or compare_investments, and it mentions LCA even though the schema enum does not include it.

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

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

The description provides no guidance on when to use this tool versus alternatives like calculate_lci_lca, calculate_tesouro_selic, compare_with_cdb, or compare_investments. The only instruction given is about using exact parameter names, which is parameter guidance rather than tool-selection 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?

No annotations are provided, so the description carries the disclosure burden. It does disclose the meaningful behavior: it applies the regressive IOF table, deducts 22.5% IR on the remainder, and even compares against waiting until day 30. That is substantial behavioral information for a calculator with no side effects.

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

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

One dense, front-loaded sentence states the purpose and calculation scope, followed by a compact parameter note. Every clause earns its place and the critical 'before 30 days' condition appears at the beginning.

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 deterministic calculation with no output schema, the description gives the legal basis, the assets covered, and the parameters. It is complete enough for an agent to select the tool, though it does not specify the shape of the return value.

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

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

The input schema already documents all three parameters at 100% coverage (principal, days, cdi_percent). The description restates which are required/optional and insists on exact English parameter names, which is useful but adds no semantic depth beyond the schema, so the baseline 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 opens with a specific action and resource: 'Calcula quanto o IOF come de um resgate feito antes de 30 dias' and lists the exact pieces of the calculation (Decreto 6.306 regressive table, 22.5% IR, waiting comparison). It is clearly not a tautology, but it never names or contrasts a sibling tool, so it stops one step short of full differentiation.

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

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

It gives a clear trigger context: redemptions before 30 days for caixinha, CDB, and Tesouro. That tells an agent when to reach for it. It does not explicitly list exclusions or name alternatives, so it earns context but not the upper bound.

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

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

With no annotations, the description carries the full burden, and it does well by disclosing the key behavioral assumptions: IR is applied to the entire nominal gain, and the output exposes the net real rate after tax. It reveals the tax impact on inflation protection, which is a non-obvious behavioral trait. It doesn't discuss edge cases or exact output structure, but for a calculator this level is strong.

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 focused sentences: first states the function and components, second conveys the key output insight, third gives parameter guidance. Every sentence earns its place, no fluff, and the most important information 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?

For a calculator with no output schema, the description covers the inputs, the calculation logic, and the main output concept. It could be more explicit about the exact return format (e.g., whether it returns a breakdown or a single number), but the stated output ('quanto da proteção contra inflação o imposto leva') gives sufficient functional understanding. Given the 100% schema coverage and moderate complexity, this is nearly 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 value by explicitly grouping required (principal, real_rate, months) vs optional (inflation) parameters and instructing the agent to 'use exactly these names, in English'. This practical guidance helps prevent parameter-name translation errors and reinforces semantics already present in the schema.

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

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

The description uses the specific verb 'Simula' and identifies the exact resource: 'renda fixa IPCA+ (CDB ou Tesouro IPCA+)'. It enumerates the key computed outputs (taxa real contratada, inflação projetada, IR sobre o ganho nominal inteiro, taxa real líquida) and the unique insight (how much tax erodes inflation protection). This clearly distinguishes it from sibling tools like calculate_tesouro_prefixado or calculate_investment_return.

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 strong context by specifying the domain (IPCA+ fixed income, both CDB and Tesouro) and the calculation scenario. However, it does not explicitly name alternative tools or state when not to use it. The usage is implied rather than contrasted with siblings.

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

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

With no annotations provided, the description carries the full burden and it does disclose the exact calculation methodology: 0.33% daily fine (cap 20%), Selic accumulated rate, and 1% of payment month. This is transparent about how it computes the result, though it does not describe output format or edge-case handling.

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

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

The description is a single dense sentence, front-loaded with the primary purpose before the calculation details. It is efficient with no wasted words, though being one long sentence could benefit from slight structural splitting for readability.

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

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

Given the tool's moderate complexity and absence of an output schema, the description adequately explains the calculation method but does not mention what the tool returns (e.g., value breakdown or total). For a calculator, this is often sufficient, but a note on output would improve 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 description coverage is 100%, so the schema already documents all three parameters. The description does not add additional parameter-specific meaning beyond the overall calculation context, meeting the baseline for complete schema coverage.

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

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

The description clearly states the tool calculates late DAS or federal tax, specifying the exact fine and interest rates. It is specific verb+resource, and the detailed calculation formula distinguishes it from other tax calculators like calculate_darf or calculate_mei_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 implies usage for late federal tax calculations but does not explicitly state when to use it versus alternatives, nor does it mention any exclusions or prerequisites. Context is inferred from the calculation details rather than explicit 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 burden and does add useful behavioral context: it says the tool uses 'o CDI de hoje do Banco Central', treats LCI/LCA as IR-exempt, and computes an equivalent CDB rate. It does not state assumptions, return format, or limitations, so coverage 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 fluff; the main function and output are front-loaded and the parameter naming reminder is a single clause. 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 three-parameter calculator with full schema coverage, the description supplies the missing context: the BC/CDI data source, the tax exemption premise, and the equivalence question being answered. The lack of an explicit output format is a minor gap for this simple numeric calculation.

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

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

The input schema already provides 100% coverage with descriptions for principal, cdi_percent, and months, so the description needs little extra. The note 'Use exatamente estes nomes, em inglês' adds a naming/language instruction but no new semantic detail 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 opens with 'Simula LCI ou LCA (isentas de IR)' and defines the tool's output: 'calcula o CDB equivalente' and 'qual percentual do CDI um CDB precisaria pagar pra empatar'. This is specific about action, resource, and result, though it doesn't explicitly name sibling tools or contrast with them, so it loses the top score.

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 makes the intended scenario clear — LCI/LCA simulation with today's BC CDI and CDB equivalence — so an agent can infer when it applies. However, it offers no explicit when-to-use versus alternatives such as compare_with_cdb or calculate_cdi_yield, nor any exclusion 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 carries the burden of explaining behavior. It discloses the calculation formula and the subtraction of existing assets, which is useful. However, it does not state the output format, units of the result, rounding behavior, or what happens when required values are missing or invalid.

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

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

The description is compact and front-loaded: the first sentence explains the method and formula, and the second lists required/optional parameters. It is efficient, though the parameter list slightly overlaps with 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?

For a calculation tool with a formula fully explained and all parameters documented in the schema, the description is complete enough to invoke correctly. The main gap is the lack of explicit output/return-value context, which is not fatal because the formula defines what will be computed.

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 each parameter's meaning. The description only repeats the parameter names and required/optional status, adding little semantic value 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: it calculates life insurance need via the DIME method. It names the exact formula components (dívidas, renda, saldo do financiamento, educação, menos patrimônio), which clearly distinguishes it from the many calculate_* 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?

It clearly identifies which parameters are mandatory (monthly_income) and which are optional, and instructs the agent to use exact English parameter names. It does not explicitly name alternative tools or exclusions, but the DIME-specific domain and parameter requirements make when-to-use reasonably clear.

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

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

With no annotations present, the description carries the full burden of behavioral disclosure. It usefully says that fixed costs, variable costs, and desired margin are included in the sale-price calculation, but it does not disclose the markup formula, output format, units, or edge-case assumptions, leaving some ambiguity about the exact 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 short sentences with the core purpose front-loaded and every sentence earning its place: purpose, parameter requirements, and naming instruction. There is no filler, repetition, or unnecessary detail.

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 low-complexity calculator with fully documented parameters, the required/optional split and naming rule are enough for an agent to invoke it correctly. Still, because there is no output schema and no return-value description, the result format is not fully explicit.

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 and the baseline is 3. The description adds only a re-statement of which parameters are required/optional and an instruction to use exact English names, which is marginally helpful but not substantive new meaning.

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

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

The description opens with a clear verb and resource — 'Calcula preço de venda com markup' — and enumerates the cost and margin components involved, so an agent understands what the tool computes. It does not explicitly contrast it with sibling calculators, but the markup/price focus is distinct enough among the listed tool names.

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 required versus optional parameters and the exact English parameter names, which helps invocation. However, it provides no guidance about when to choose this tool over alternatives such as calculate_break_even or calculate_gross_from_net, and no when-not-to-use conditions.

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

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

With no annotations, the description carries the full burden of behavioral disclosure. It does disclose the two main behaviors: computing the monthly DAS value and checking whether revenue is within the limit. However, it does not describe the output format, the specific annual limit used, or how activity choices affect the tax breakdown beyond what the schema already states.

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 with the core purpose. The second and third sentences clearly organize required vs optional parameters and reinforce exact naming. It is slightly redundant with the schema, but no sentence is wasted.

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

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

There is no output schema, so the description should clarify what the tool returns, such as the DAS amount and a boolean indicating whether the revenue limit is respected. It also omits the annual revenue limit value and how it is derived. These are meaningful gaps for an agent deciding how to use the result.

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

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

The schema already provides 100% parameter documentation, including the activity enum's tax implications and monthly_revenue's meaning. The description only restates which parameters are required/optional and instructs the agent to use exact English names, adding no substantive semantic information 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 identifies the operation: it calculates the monthly DAS MEI amount and checks the revenue limit. It is specific enough to separate this tool from generic tax calculators, though it never explicitly names or contrasts sibling tools such as calculate_late_das or calculate_simples_nacional.

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 parameter-level instructions (required/optional) but no guidance about when to choose this tool over alternatives. It does not state prerequisites, exclusions, or situations in which another calculator would be more appropriate, so the agent is left to infer the context from the name and description.

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 burden of explaining behavior. It does so by disclosing the formula: the contractual penalty (default of 3 rents) prorated by the remaining months. It does not mention output format, rounding, or edge cases like months_fulfilled exceeding contract_months, but the core behavioral model is clear.

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 carry the full picture: what is calculated, the legal rule, the required/optional parameters, and exact naming instructions. There is no filler or restatement of schema fields.

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 four-parameter calculator with fully documented schema fields, the description provides enough to invoke it correctly: formula, defaults, and required parameters. It does not describe the return value or boundary behavior, but those gaps are minor given the schema coverage and 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 the schema already documents each parameter's meaning and defaults. The description reinforces required/optional status and instructs the agent to use the exact English names, which is useful but adds little semantic value 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 starts with the specific verb 'Calcula' and a precise resource: the early-termination penalty of a rental contract. It explains the exact legal basis and proportional-calculation logic, which clearly sets it apart from sibling calculators such as calculate_rent_adjustment.

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 — early termination of a rental contract under art. 4º of the Lei do Inquilinato — and explicitly labels required vs optional parameters. It does not name alternative tools or state when not to use it, but the domain-specific context is strong enough to guide selection.

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

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

With no annotations, the description carries the full burden and does disclose meaningful behavior: it uses today's INSS/IRRF tables or a past table via reference_date, and it clarifies required vs optional inputs. It doesn't mention return format or rounding, but the core calculation 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?

Three compact, front-loaded sentences with no filler. The main function is stated first, followed by the historical nuance and the parameter usage note, all of which earn their 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 simple calculator with fully documented schema parameters, the description covers the core behavior, the historical-table feature, and parameter naming guidance. With no output schema, it could have described the return structure, but the net salary outcome is strongly implied by the tool name and description, so this is a minor 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 baseline is 3. The description adds value by stating the required/optional classification, instructing the agent to use exact English parameter names, and giving a concrete reference_date example ('refazer a folha de novembro de 2025'). This exceeds what the schema alone provides.

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

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

The description uses a specific verb ('Calcula') and resource ('salário líquido CLT no Brasil') and identifies the key deductions (INSS and IRRF), making the tool's core function unambiguous. It does not explicitly name or contrast sibling tools such as calculate_gross_from_net, so it stops short of full sibling differentiation.

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

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

The description provides clear context for when to use the tool: computing net CLT salary, including a historical use case via reference_date. It lacks explicit exclusions or alternatives, but the purpose is specific enough that an agent can correctly select this tool over salary-related 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?

Sem anotações, a descrição carrega o ônus de revelar o comportamento. Ela informa que a ferramenta mostra o gap e o aporte para o próximo marco, o que é útil. Não declara premissas (ex.: anualização da renda mensal) nem limites, mas o escopo essencial está presente.

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?

Duas frases sem conteúdo desperdiçado. A função principal vem primeiro, a regra é resumida em poucos parênteses e os parâmetros são listados no final. Nada é repetido desnecessariamente.

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?

Não há output schema, então a descrição precisa explicar o retorno, o que faz ao mencionar gap e aporte. Contudo, 'aporte' é ambíguo (mensal? anual? total?). Com os três parâmetros totalmente documentados no schema, a lacuna é pequena.

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?

O schema já descreve 100% dos parâmetros com clareza. A descrição acrescenta apenas a obrigatoriedade e a instrução de usar nomes exatos em inglês, o que é útil, mas não adiciona significado semântico além do 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?

A descrição usa verbo específico ('Compara'), recurso claro (patrimônio investido vs. régua de referência por idade) e detalha a regra com múltiplos específicos. Isso a distingue imediatamente de ferramentas irmãs como calculate_first_million ou calculate_financial_independence.

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?

O contexto de uso é claro: comparar patrimônio com referência etária. Porém, não há menção explícita a alternativas ou exclusões, mesmo havendo muitas calculadoras irmãs similares na lista. A função autoexplicativa compensa parcialmente essa lacuna.

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