OpenLMNP

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

Given destructiveHint=true, the description adds useful behavioral context such as the storage path ('documents/{user_id}/{type}/{filename}') and the requirement for file_path to have MCP_FILE_PATH_PREFIX. However, it does not disclose potential side effects like overwriting existing documents or what happens on duplicate attachments, leaving some ambiguity beyond the annotation.

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, using only two sentences. The first sentence delivers the core purpose, and the second packs the input modes and storage path efficiently. There is no fluff, and the structure front-loads the most important information.

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

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

The tool is moderately complex with 9 parameters, no output schema, and no parameter descriptions. The description covers the file modes but leaves required parameters like record_id and label undefined, and does not clarify the meaning of type beyond its use in the storage path. It also omits any constraints on file size/type and what the tool returns, making it incomplete for reliable 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?

The description significantly clarifies the three file-input parameters (file_base64, file_path, file_url) and indirectly explains filename via the storage path. It also hints at the meaning of type through the storage path. However, with schema description coverage at 0%, it does not explain record_id, label, amount, or document_date, leaving ambiguity for about half the parameters.

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 action ('Attache un document justificatif'), the object ('document'), and the target records ('une charge, un mobilier ou un poste de travaux'). It also specifies document types (facture, reçu, devis) and distinguishes itself from sibling tools like delete_document or export_documents.

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 explicit usage guidance by listing three mutually exclusive input modes (file_base64, file_path, file_url) and calls out the prerequisite for file_path (MCP_FILE_PATH_PREFIX). It implies when to use this tool (to attach a document to a record) but does not explicitly discuss alternatives or exclusions, though that is largely self-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?

Beyond the readOnlyHint annotation, the description adds useful behavioral details: it specifies the abatement rates (50% for classified, 30% for non-classified) and clarifies that all amounts are in euros. It also explains that the tool calculates taxable results and indicates the more advantageous regime, providing insight into its logic. However, it does not mention any limitations (e.g., dependence on existing data) or whether it returns a detailed breakdown vs. a summary.

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

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

The description is concise, containing three sentences that all add value. It front-loads the core purpose, then explains the calculation, and finally provides key legal/contextual details. No redundant or irrelevant information is present, 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?

For a read-only comparison tool, the description covers the essential aspects: what it does, how it calculates (abatement rates), and output indication. However, with no output schema, it does not describe the return value's structure or content in detail. It also does not mention any dependencies on existing fiscal data or the potential need for both regimes to be available. This leaves some gaps in 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 0%, so the description must compensate for both parameters. It explicitly mentions 'year' via 'pour une année fiscale', but the optional 'abatement_rate' parameter is not linked to the description. The description mentions predefined abatement percentages but does not explain how the abatement_rate parameter interacts with them (e.g., as an override). This leaves the parameter's semantics unclear, especially since it is optional.

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: comparing the micro-BIC and actual tax regimes for a fiscal year. It specifies the verb 'compare', the resource (tax regimes), and the scope (a given year). This distinguishes it from sibling tools like compute_fiscal_year or generate_tax_return, which focus on computation or filing rather than comparison.

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

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

The description implies when to use the tool (when a comparison between micro-BIC and actual regimes is needed) but does not explicitly state alternatives or exclusions. It lacks guidance on prerequisites, such as whether data for both regimes must be present, or when another tool might be more appropriate. This leaves the usage context somewhat 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?

Annotations already declare readOnlyHint=true, and the description adds that it returns a breakdown by component and total, all in euros. This gives a clear picture of the output without an output schema, going beyond the annotation.

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

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

A single, front-loaded sentence packs all necessary information: what it does, for what inputs, and what it returns. No wasted words.

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

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

With two params, a read-only annotation, and no output schema, the description covers the purpose, inputs, and output breakdown. It doesn't mention potential errors or prerequisites, but for a calculation tool this is acceptable and complete 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 0%, so the description must compensate. It mentions 'property' and 'year' in natural language, mapping to property_id and year, but doesn't explicitly define each parameter or their formats. It provides enough semantic context but could be more explicit.

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

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

The description clearly states the tool computes LMNP depreciation for a property and year, and specifies the output components (building, works, furniture, total). This distinguishes it from sibling compute tools like compute_tva, compute_loan_schedule, and compare_micro_bic.

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: use for a given property and year. While it doesn't explicitly mention alternatives or when-not to use, the tool name and description make its use case unambiguous among the siblings.

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

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

Beyond the idempotentHint annotation, the description discloses the side effect of creating the fiscal year ('Crée l'exercice s'il n'existe pas encore'), details of the depreciation cap and carryforward ('plafonnement et report'), and that amounts are returned in euros. This adds substantial behavioral context beyond the annotation.

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 main purpose and components, and the second adds side effects and return currency. Every sentence contributes essential information 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?

Given the tool's complexity and absence of an output schema, the description covers key outputs and side effects well, including depreciation capping and currency. However, it does not describe the exact response structure or format, which would be helpful for a tool returning multiple computed values.

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

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

The input schema has only one parameter (year) with zero description coverage. The description indirectly clarifies that 'year' refers to the fiscal year ('pour une année donnée') but does not explain validation, format, or constraints. This partially compensates for the lack of schema description but is not comprehensive.

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 'Calcule le résultat fiscal complet d'un exercice LMNP pour une année donnée' and lists the specific components (recettes, charges, amortissements, résultat fiscal net, solde TVA). This distinguishes it from sibling tools like compute_depreciation and compute_tva, which focus on narrower aspects.

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 (for a complete fiscal year calculation) but does not explicitly mention when not to use it or suggest alternatives. It mentions side effects (creating the exercise if missing), which is useful, but falls short of explicit exclusion guidance.

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

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

The description goes beyond the destructiveHint annotation by detailing exactly what is deleted ('Supprime les échéances existantes') and what is recalculated (capital, interest, insurance). It also discloses the return value (financial summary, first and last installment) and currency (EUR), providing rich behavioral context without contradicting annotations.

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

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

The description is three concise sentences, each providing distinct and necessary information: what the tool does, what it destroys/recalculates, and what it returns. No unnecessary words or repetition, and the key destructive behavior 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 tool with a single parameter and no output schema, the description is quite complete. It explains the main operation, the destructive effect, the components recalculated, and the nature of the response. It lacks explicit alternative tool guidance, but the overall context 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?

The input schema is minimal with a single required integer loan_id. The description does not mention this parameter or add any additional meaning beyond the schema. However, given that the parameter is highly self-explanatory from the tool name and schema, the schema is sufficient. The description adds no value here, but the low parameter count and clear name keep it adequate.

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

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

The description clearly states the tool's purpose: it generates or regenerates the amortization schedule for a real estate loan. The verb 'génère' is specific, and the resource 'tableau d'amortissement' is well-defined. It also distinguishes itself from the sibling tool 'get_loan_schedule' by emphasizing recalculation and deletion of existing installments.

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 generating or regenerating a loan schedule, but it does not explicitly state when to use this tool versus alternatives like 'get_loan_schedule'. No clear when-to-use or when-not-to-use guidance is provided, only an implied context for recalculating payments.

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

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

The readOnlyHint annotation already indicates this is a read-only operation, so the description adds value by detailing what is returned (TVA collectée, déductible, solde) and the aggregation dimensions (bien, taux, trimestre). This goes beyond the annotation and clarifies the calculation scope, though it does not mention error handling or prerequisites.

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 exceptionally concise: two sentences that front-load the main verb and purpose, then detail outputs. No redundant information or filler. Every phrase adds meaning, from the target population to the currency.

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

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

Given the tool has only one parameter and no output schema, the description adequately covers the return value structure and scope. It explains the outputs and their segmentation, which is sufficient for an agent to understand what the tool provides. It misses only minor details like data source dependencies (existing properties, fiscal year definitions), but these are not critical for effective 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?

The schema only defines 'year' as an integer with no description (0% coverage), so the description must compensate. It does so by stating 'sur une année donnée' (for a given year), directly clarifying the parameter's meaning. However, it does not specify constraints like valid year range or format beyond the implicit integer type, leaving some ambiguity for edge cases.

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 ('Calcule' / calculates) and resource (VAT declaration for taxable para-hotel properties) along with the output composition (collected VAT, deductible VAT, balance) and breakdown (by property, rate, quarter). This distinguishes it from sibling tools like compute_depreciation or generate_tax_return, which address different financial scopes.

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 by specifying the context (para-hotel properties, taxable regime, given year) but does not explicitly contrast with alternatives such as generate_tax_return or compute_fiscal_year. There is no 'when-not-to-use' or mention of sibling tools, leaving the agent to infer applicability rather than receiving explicit 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?

The description says the tool 'creates' an expense, while the annotation indicates destructiveHint: true. This is a direct contradiction, as creation is not inherently destructive. The description does not disclose any destructive behavior or side effects, and the conflicting annotation makes the tool's behavior unclear.

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, using one sentence plus a list of categories. It is front-loaded with the action and contains no filler. The only minor issue is the French wording potentially causing translation overhead, but it is still 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?

For a tool with 9 parameters, no output schema, and a confusing annotation, the description is incomplete. It does not mention required fields, return values, prerequisites, or potential side effects beyond creation. The category list and amount unit are helpful, but the overall context is insufficient for an agent to fully understand the tool's behavior.

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

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

The description adds meaning for two parameters: amount is 'en euros' and category lists valid values. However, with 0% schema coverage and 9 parameters total, it leaves the other seven (property_id, expense_date, description, notes, tva_rate, is_dedicated, recurring_type) unexplained. The partial info does not sufficiently compensate for the lack of schema descriptions.

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

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

The description clearly states the action: 'Crée une charge d'exploitation pour un bien LMNP' (creates an operating expense for an LMNP property). The verb 'crée' and the resource 'charge d'exploitation' are specific, and the context 'bien LMNP' distinguishes it from related tools like create_income or create_property.

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 context (for an LMNP property) and lists categories, implying when the tool should be used. However, it does not explicitly mention alternatives or exclusions, such as using update_expense for modifications or creating income via create_income. The guidance is implied rather than stated.

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

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

The description contradicts the annotations. Annotations declare destructiveHint=true, implying destructive behavior, but the description states this tool 'creates' a new furniture record. This is a direct contradiction, so the score must be 1 per the rubric.

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 concise, front-loaded sentences. Each sentence provides essential information: what is created, the currency of the amount, and the depreciation rules. There is no redundancy 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?

There is no output schema, so the description should clarify return values, but it does not. Additionally, the annotation contradiction and lack of explanation for several parameters leave the tool under-specified. The description covers the LMNP context and depreciation defaults, but missing side effects, return value, and parameter details make it 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?

The description adds valuable semantics for some parameters: it specifies that 'amount' is in euros and explains the default duration (5 years) and the 3-year duration for second-hand furniture, which relates to 'duration_years' and 'is_second_hand'. However, it does not explain tva_rate, is_dedicated, or the format/role of purchase_date, leaving gaps for several parameters.

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: 'Crée un élément de mobilier amortissable pour un bien LMNP' (creates a depreciable furniture item for an LMNP property). This is a specific verb+resource, and the mention of 'mobilier' distinguishes it from sibling tools like create_expense or create_property.

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

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

The description provides clear context: it is for creating furniture items within an LMNP property, with depreciation specifics (5 years default, 3 for second-hand). However, it does not explicitly state when not to use it or mention alternative tools, so it lacks explicit exclusions.

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

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

The annotations declare destructiveHint: true, while the description says the tool creates income, which is a direct contradiction. The description does not disclose any side effects, irreversibility, or permission requirements. The only added behavioral details are currency format and source enums, which do not address the destructive nature flagged by annotations.

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

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

The description is concise, containing exactly two sentences that lead with the primary action and then provide key domain constraints. Every clause adds value, and it is well-structured for quick consumption.

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 12 parameters, no output schema, and a zero-coverage schema, the description is far too sparse. It omits required fields, return behavior, and any interaction with related entities (e.g., property, tax calculations). The description is adequate only for a very simple tool, which this is not.

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

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

With 0% schema description coverage, the description must compensate, but it only explains two parameters: amount (euros) and source (enumerated values). The required parameters property_id and income_date are not mentioned, nor are the many optional fields like tva_rate, platform_fee, or guest_name. This leaves most of the 12 parameters semantically unexplained.

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

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

The description clearly states the tool's function: 'Crée un revenu locatif pour un bien LMNP' (Creates rental income for an LMNP property). It uses a specific verb ('crée') and resource ('revenu locatif'), and differentiates from sibling tools like create_expense and create_furniture by specifying the income context. The source examples further clarify the 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 implies when to use the tool (recording rental income) but does not explicitly state alternatives or exclusion criteria. It says the source can be airbnb, booking, etc., which gives context, but there is no comparison to other create_* tools or guidance on prerequisites.

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

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

Annotations provide destructiveHint: true, and the description clarifies the operation creates a new property for the connected user. It does not add deeper behavioral context such as irreversibility, permissions, or what exactly happens upon success, so it is minimally adequate but not comprehensive.

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

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

The description is a single, efficient sentence followed by concise enumerations. Every element adds value, and the structure front-loads the core action before listing parameter conventions. No filler or repetition.

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

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

With 19 parameters, no output schema, and no parameter descriptions, this tool requires more contextual support than the description provides. It does not mention return values, error behavior, date formats, or examples, making it incomplete for complex use 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?

The schema has 19 parameters with 0% coverage, and the description adds useful meanings by stating units (euros, m²) and allowed values for type, rental_type, and tva_regime. However, many other parameters such as acquisition_date, land_percentage, and is_primary_residence remain unexplained, leaving significant gaps.

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 'Crée' and the resource 'nouveau bien immobilier LMNP', clearly indicating a create operation for a new property. It also scopes to the connected user, which distinguishes it from sibling tools like update_property, get_property, and list_properties.

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

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

The description implies use for creating a property but does not explicitly state when to use it versus update_property or other create tools. It lacks direct usage guidance or exclusions, though the context makes the basic intent obvious.

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

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

The description adds valuable behavioral context beyond the annotations: amount is in euros, default 10-year depreciation, automatic annual depreciation calculation, and quote-part handling for non-dedicated items. It does not contradict the destructiveHint=true annotation, though the annotation is not explained. The description could mention irreversible effects, but it already reveals key calculation 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 3 sentences, front-loaded with the purpose, and every sentence adds relevant information. There is no fluff or repetition of schema attributes. It is appropriately sized and well-structured.

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

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

Given 7 parameters, no output schema, and only a destructive hint annotation, the description should explain more: required parameters, return values, and any side effects. It focuses on the depreciation calculation but omits essential operational details like what is returned or how tva_rate and work_date are used, making it incomplete for a create 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?

The schema has 0% description coverage, so the description is the only source for parameter meaning. It explains 'amount' unit, 'duration_years' default, and 'is_dedicated' affects quote-part, but it leaves property_id, description, work_date, and tva_rate completely unexplained. This is insufficient for a 7-parameter create operation.

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: 'Crée un poste de travaux immobiliers amortissables pour un bien LMNP' (Creates a depreciable real estate work item for a LMNP property). This uses a specific verb and resource, and it distinguishes itself from sibling tools like create_expense or create_furniture by focusing on 'travaux' (work) and 'amortissables' (depreciable).

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

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

The description implies usage context (for LMNP properties) but does not explicitly state when to use this tool versus alternatives such as create_expense or create_furniture. It lacks exclusions or alternative tool references, so the agent must infer from the name and context.

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

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

Annotations include destructiveHint=true, and the description adds key context beyond that: the physical file is also removed from storage and the action is irreversible. This helps the agent understand consequences not implied by the annotation alone.

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

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

Two concise sentences. Each adds value: what is deleted, the physical file deletion, and irreversibility. No fluff or repetition 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?

The tool is simple (one parameter, no output schema). The description, combined with the destructiveHint annotation, fully covers the essential behavior: what is deleted, how, and permanent consequences. No significant gaps for an agent to invoke it correctly.

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

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

Schema coverage is 0% for the single parameter document_id. The description clarifies the parameter is the document's identifier, but provides no further detail about format, source, or constraints. This is minimal but sufficient for a simple integer ID.

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 deletes a supporting document (document justificatif) by its ID. It uses a specific verb ('Supprime') and resource, distinguishing it from sibling delete_* tools such as delete_expense or delete_furniture.

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 purpose is clear: use when deleting a document. It doesn't explicitly mention alternatives or exclusions, but the context implies this is the tool for deleting supporting documents, and sibling names differentiate by resource type. No misleading guidance.

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

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

Annotations already include destructiveHint, but the description adds valuable context: it explicitly states that supporting documents are also deleted and the action is irreversible. These details go beyond the annotation and inform the user of important side effects.

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

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

The description is three short sentences, front-loaded with the main purpose. It is concise with no redundant information, and every sentence adds meaningful 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 simple delete tool with one parameter and no output schema, the description covers the main purpose, side effects (document deletion), and irreversibility. It is adequate, though it does not mention error conditions or return values, which are minor for this type of 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 0%, so the description must clarify the parameter. It mentions 'par son identifiant' which explains expense_id as the identifier, but provides no additional details about type or source. Since the parameter name is self-explanatory, the added value is minimal.

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 deletes an operating expense by its identifier, using a specific verb and resource. It also mentions that associated supporting documents are deleted, distinguishing it from sibling delete tools like delete_document or delete_furniture.

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 deleting an expense and its associated documents, but does not explicitly state when to use it vs. alternatives. No exclusions or alternative tool references are provided, so the guidance 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?

The description goes beyond the destructiveHint annotation by explicitly stating the action is irreversible and that associated supporting documents are also deleted. This provides valuable behavioral context about cascade effects and permanence.

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

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

The description is three short sentences, front-loaded with the primary action and followed by two critical caveats. No unnecessary words or repetition.

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

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

For a simple single-parameter delete tool, the description covers the core action, irreversibility, and cascading side effect. It lacks an output specification (though no output schema exists) and does not mention error cases, but these are not critical for such a straightforward operation.

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

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

Schema description coverage is 0%, and the description only refers to 'son identifiant' (its identifier), which adds minimal meaning beyond the schema's furniture_id field. It does not explain the nature of the identifier, how to obtain it, or any constraints beyond what the schema already shows.

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 action (deletes) and the resource (furniture item by identifier), and distinguishes it from sibling delete tools by specifying the furniture context. It also mentions cascade deletion of associated documents, adding precision.

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

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

The description implies when to use the tool (when deleting a furniture item by ID) but does not explicitly state alternatives or exclusions. The warning about associated documents being deleted hints at consequences but does not compare with delete_document or other 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?

The annotation destructiveHint=true already signals destructive behavior. The description adds 'irréversible' (irreversible), reinforcing the destructive nature but not disclosing additional behavioral traits like cascading effects or authorization requirements.

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, extremely short, and to the point. Every word adds value without unnecessary fluff.

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

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

For a simple tool with one parameter and destructive annotations, the description is largely complete. It states the action, target, and irreversibility. It could mention prerequisites or side effects, but for a basic delete-by-ID operation, this is adequate.

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

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

Schema coverage is 0%. The description says 'par son identifiant' (by its identifier), explaining that the parameter identifies the income to delete, but it does not name the parameter (income_id) or specify its type. This adds some meaning but could be more explicit.

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 'Supprime' (deletes), the resource 'revenu locatif' (rental income), and the method 'par son identifiant' (by its identifier). This distinguishes it from sibling delete tools like delete_expense or delete_document.

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 it clear this tool is for deleting a rental income by ID, implying use when you need to remove such a record. It does not explicitly name alternatives or exclusions, but the context is sufficient for a straightforward delete operation.

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

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

The annotations already declare destructiveHint=true, but the description adds critical beyond-annotation context: 'Les documents justificatifs associés sont également supprimés' (associated supporting documents are also deleted) and 'Cette action est irréversible' (this action is irreversible). This discloses cascading side effects and permanence.

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, front-loaded sentences each add essential information: the action, the cascading deletion, and irreversibility. No redundancy, perfectly sized.

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

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

For a single-parameter delete operation with no output schema, the description covers the action, side effects, and irreversibility, providing sufficient context for an agent to invoke it correctly.

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

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

The input schema only lists work_id as an integer. The description clarifies that work_id is the identifier of the property work, giving semantic meaning to the parameter. With 0% schema description coverage, this is helpful though not exhaustive.

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 action with a specific verb and resource: 'Supprime un poste de travaux immobiliers par son identifiant' (deletes a property work item by its identifier). It also distinguishes from sibling delete tools by explicitly mentioning 'travaux immobiliers' (property works).

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 that this tool is for deleting property works and warns that associated documents are also deleted. It does not explicitly name alternative tools or provide when-not-to-use guidance, but the context is sufficient for basic 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?

The annotation readOnlyHint=true already establishes this as a non-mutating operation. The description adds valuable behavioral details: the output is a ZIP file, organized by year and type, and it returns a temporary download URL. This goes beyond the annotation without contradicting it.

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

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

The description is two sentences in French, front-loaded with the core action, and includes all essential details (content, organization, filtering, return URL) without redundancy or extraneous 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?

Given the simplicity of the tool (2 optional params, no output schema) and the readOnly annotation, the description covers all necessary aspects: it defines the output format, the document scope, the optional filters, and the return value. It is sufficiently complete for an agent to select and invoke the tool correctly.

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

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

The schema provides only bare parameter names (type, year) with no descriptions (0% coverage). The description compensates by explaining that these are optional filters and provides example values for type (charges/mobilier/travaux), clarifying the semantics of both parameters.

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 'Génère un fichier ZIP' (generates a ZIP file), a specific verb and resource, and details the content (all supporting documents) and organization (by year and type). This clearly distinguishes it from sibling tools like attach_document or delete_document, which serve different purposes.

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

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

The description clearly indicates the tool's purpose—exporting all user documents as a ZIP—and notes optional filtering by year/type. It doesn't explicitly mention exclusions or alternatives, but since no sibling tool performs a similar export, the use case is well-defined and the context is clear.

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

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

With no annotations, the description discloses key behaviors: generating a standardized file, calculating the fiscal year when needed, and returning a file path. It does not mention side effects or error handling, but covers the essentials.

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, front-loaded with the core purpose, and each sentence adds valuable context (legal basis, format, output) without unnecessary verbosity.

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 tool's purpose, legal framework, output format, and return value, making it sufficiently complete for a one-parameter tool with no output schema.

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

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

The single 'year' parameter is clarified as the fiscal year, and the description notes that the exercise is calculated automatically, adding meaning beyond the bare integer 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 'Génère' and clearly identifies the resource (FEC) with regulatory detail, distinguishing it from siblings like generate_tax_return and export_documents.

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 explains that the FEC is a mandatory regulatory file for tax audits, indicating when to use it, but does not explicitly list alternatives or 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 empty annotations, the description carries the transparency burden. It discloses that the fiscal year is recalculated before generation and that it returns a PDF path and key amounts, implying file creation and possible data recalculation. However, it does not state whether the recalculation mutates persistent data or whether any permissions are required.

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, front-loaded with the core action and output. Every sentence adds value: purpose, recalculation behavior, and return 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?

The description covers the main action, inputs, and return value, but lacks details on prerequisites (e.g., whether compute_fiscal_year must be called first), side effects on persistent data, and error conditions. Given no output schema or annotations, this is a moderate 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 only parameter 'year' has no schema description (0% coverage). The description adds that it is the fiscal year and that it may be recalculated, but does not specify expected format, range, or meaning beyond the name.

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 (Génère) and resource (liasse fiscale LMNP au format PDF), naming the exact forms and the fiscal year scope. This distinguishes it from siblings like generate_fec or compute_fiscal_year.

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?

Provides clear context: used to generate a PDF tax return for a given fiscal year, and mentions that the fiscal year is recalculated if necessary. However, it does not explicitly say when not to use it or name 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 readOnlyHint already declared, the description adds useful behavioral nuances such as the default to current year and the conditional inclusion of fiscal result only if it exists. No contradiction with the readOnly annotation.

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

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

The description is a single sentence that front-loads the main purpose and packs all key details without redundancy or filler. Every part 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?

Since there is no output schema, the description appropriately enumerates the return contents (counts, totals, fiscal result, breakdowns). It lacks exact field names or error handling but is sufficiently complete for an agent to understand the tool's 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 only parameter 'year' is fully explained in the description (years requested, defaults to current year), compensating entirely for the 0% schema description coverage. The meaning is unambiguous.

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

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

The description clearly states the tool returns an aggregated dashboard for the user and enumerates specific contents (number of properties and loans, income/expense totals, fiscal result, breakdowns), which distinguishes it from sibling tools like get_projection or get_simulation.

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 by specifying it is user-scoped and mentions the default year, but it does not explicitly contrast with alternative tools or state when not to use it. This fits 'clear context, no 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?

Annotations already declare readOnlyHint=true; the description adds field-level details including the effective amount after quote-part logic, which is beyond the annotation. It does not discuss error cases or permissions, but for a read operation with annotation coverage, this is acceptable.

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

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

A single sentence with a colon-led list; it's dense but informative, and the main purpose is front-loaded.

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

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

The description enumerates the key return fields (TTC/HT, TVA, category, recurrence, flag, effective amount), which compensates for the absence of an output schema. It doesn't address not-found behavior, but for a simple get-by-id tool it is reasonably complete.

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

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

The schema has 0% description coverage, and the description only states 'par son identifiant' (by its identifier), which merely restates the parameter name expense_id. It doesn't explain the ID's source, format, or constraints, failing to compensate for the schema gap.

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

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

The description uses the specific verb 'Retourne' (returns) targeting resource 'charge' (expense) by its identifier, and enumerates the fields returned, clearly distinguishing it from list/create/update/delete expense 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 context is clear: use when you need the full detail of a single expense given its ID. It does not explicitly mention alternatives like list_expenses, but the 'par son identifiant' scoping implies singular fetch.

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

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

The readOnlyHint annotation already declares this as a safe read operation. The description adds value by listing the exact data fields returned, providing useful behavioral context beyond the annotation. However, it does not discuss error behavior or prerequisites, so it is not fully transparent.

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

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

The description is a single, dense sentence that front-loads the main action ('Retourne le détail complet') before listing the returned data. There is no filler or 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 one-parameter read tool with a readOnlyHint annotation, the description thoroughly enumerates the returned data, which is essential because no output schema exists. It does not cover edge cases like missing years, but it is otherwise complete given the tool's simplicity and the annotation's coverage.

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

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

Schema description coverage is 0%, but the description mentions 'par son année' (by its year), clarifying that the integer 'year' refers to the fiscal year. This adds meaning beyond the bare integer type, though it lacks constraints like range, format, or examples. For a single simple parameter, this is adequate.

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

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

The description uses a specific verb and resource ('Retourne le détail complet d'un exercice fiscal') and enumerates concrete fields (résultat fiscal, recettes, charges, amortissements, TVA, form_data, télétransmission), clearly distinguishing it from sibling tools like 'list_fiscal_years' (which lists all fiscal years) and 'compute_fiscal_year' (which computes something).

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

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

No explicit guidance is given about when to use this tool versus alternatives. The context implies it is for retrieving details of a specific fiscal year, but it does not mention using 'list_fiscal_years' for discovery or 'compute_fiscal_year' for calculations, so usage guidance remains implied.

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

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

Annotations already declare readOnlyHint=true, so the agent knows this is a safe read. The description adds useful context about the response contents (amounts, fees, taxes, reservation info), but it does not disclose potential error behaviors, authorization requirements, or any constraints beyond the read-only hint. This is comparable to the get_calls calibration example, achieving a baseline of 3.

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

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

The description is a single, dense sentence that front-loads the verb ('Retourne') and resource ('détail complet'), then efficiently enumerates the key data fields. No words are wasted, and all information is relevant. It is concise yet comprehensive enough.

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

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

The tool is simple: one parameter, read-only, with no output schema. The description effectively fills the gap by listing the expected return fields. It informs the agent what data will be available. It could mention the single-object nature or distinguish from list_incomes, but the description is complete enough for an agent to decide when to use 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?

The schema has one parameter, income_id, with no description (0% schema coverage). The description compensates by stating 'par son identifiant' (by its identifier), directly linking income_id to the rental income being fetched. The parameter name itself is self-explanatory, and the description reinforces its purpose. Given the low schema coverage, this added clarity is valuable, leading to a score above baseline.

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

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

The description clearly states the tool's function: 'Retourne le détail complet d'une recette locative par son identifiant' (returns complete rental income detail by ID). It lists the specific data returned (TTC/HT, TVA, fees, etc.), which distinguishes it from sibling tools like list_incomes (which likely lists all) and create_income/update_income/delete_income.

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 when you have a specific income identifier and need full details. It does not explicitly name alternatives or exclusions, but the 'par son identifiant' makes the context clear. Since this is a standard get-by-ID pattern, the absence of explicit alternative guidance is acceptable, though mentioning 'use list_incomes for overview' would be stronger.

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

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

The annotation readOnlyHint=true aligns with the description's 'retourne' (returns). The description adds some context by enumerating the returned financial fields, but does not disclose error handling, required permissions, or other behavioral details. With annotations already covering safety, the added value is moderate.

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

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

The description is a single sentence that efficiently lists the key return fields without unnecessary words. It is front-loaded with the verb and resource, though the enumeration makes it slightly long; each item is relevant and 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?

With only one parameter and no output schema, the description adequately explains the return value by listing the financial summary fields. However, it does not address input parameter format, error responses, or how this relates to the loan schedule tool, which 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?

The input schema has one required parameter, loan_id (integer), with no description, and the tool description does not mention this parameter. Schema description coverage is 0%, and the description fails to compensate by explaining the identifier's role or 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 clearly states the tool returns the complete details of a real estate loan with a financial summary listing key fields (capital, rate, duration, etc.). It identifies the resource (loan) and the action (retrieve), but does not explicitly differentiate from sibling tools like get_loan_schedule or list_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 provides no guidance on when to use this tool versus alternatives such as get_loan_schedule or list_loans. There is no mention of use cases, exclusions, or prerequisites.

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

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

Annotations declare readOnlyHint: true, so the safety profile is covered. The description adds value by detailing the row fields (échéance, date, capital, intérêts, assurance, total, restant dû) and period totals, effectively describing the output structure in the absence of an output schema.

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

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

The description is concise, two sentences, with the main purpose front-loaded and specific details following. No redundant or filler 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 read-only retrieval tool with two parameters and no output schema, the description covers the return content and optional filtering. It lacks information on error handling or loan-not-found scenarios, but these are not critical for basic usage.

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 has no property descriptions (0% coverage). The description explains the 'year' parameter as an optional filter but does not explain the required 'loan_id' parameter, leaving its role to be inferred from the tool name and context.

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

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

The description uses a specific verb 'Retourne' and identifies the resource as the complete amortization schedule of a loan, with an optional year filter. This clearly distinguishes it from sibling compute_loan_schedule, which suggests calculation rather than retrieval.

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

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

The description implies the tool is for retrieving an existing loan's schedule but does not explicitly state when to use it versus alternatives like compute_loan_schedule. No exclusions or alternative tool names are mentioned.

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

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

Annotations already declare readOnlyHint=true, covering the safety profile. The description adds context about the reported onboarding steps and that it targets the current year, but it does not explain default behavior (e.g., handling of the optional 'year' parameter) or the return format.

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

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

The description is a single sentence with a clear, front-loaded main purpose and a list of example contents. It is reasonably concise and avoids irrelevant 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?

With no output schema, the description only partially describes what is returned (the list of onboarding steps) but lacks any indication of the data format or how the optional year parameter affects the result. It is incomplete for a tool with an optional parameter.

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

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

The schema has one optional integer 'year' with no description and 0% schema description coverage. The description completely omits any mention of the parameter; saying 'current year' could mislead the agent into thinking the year cannot be specified. This is a significant gap.

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

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

The description clearly states it returns the user's LMNP onboarding progress for the current year and lists the tracked steps (property creation, income/expense recording, depreciation configuration, closing, tax PDF generation). It uses a specific verb 'Retourne' and a specific resource, but does not explicitly distinguish from sibling tools like get_dashboard_summary.

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

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

No explicit guidance on when to use this tool versus alternatives. It only implies use for checking onboarding progress, with no exclusions or mention of sibling tools that might be more appropriate for specific 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?

Annotations already declare readOnlyHint: true. The description adds significant behavioral context by detailing the per-year output components (revenues, expenses, depreciation, capping, carryforward, net result, micro-BIC comparison), which is valuable beyond the annotation's simple read-only hint.

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

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

The description is concise and well-structured: two sentences that front-load the core function and then enumerate the output. Every sentence serves a purpose, and the list is organized logically.

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

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

The description thoroughly explains the output structure, which is important given there is no output schema. However, it lacks any information about input parameters, which is a notable gap for a tool with 4 parameters and no schema descriptions. The description covers the 'what' well but not the 'how' of 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?

With 0% schema description coverage, the description must compensate for parameter meaning but does not. It makes no mention of years, start_year, income_growth, or expense_growth. The parameter names are somewhat self-explanatory, but the description adds zero value to understanding their semantics or defaults.

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 ('Calcule') and clearly identifies the resource ('projection pluriannuelle du résultat fiscal LMNP') and scope ('sur plusieurs années'). It distinguishes itself from siblings like compute_fiscal_year and compute_depreciation by emphasizing the multi-year and comprehensive nature.

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 a multi-year scenario and includes a micro-BIC comparison, providing context for when it might be used. However, it does not explicitly state when to use this tool versus single-year alternatives (e.g., compute_fiscal_year) or provide any 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?

While annotations already declare readOnlyHint=true, the description adds valuable behavioral context by detailing what the response includes (financial amounts, depreciable base, counts of components, works, furniture, loans). This goes beyond the annotation and clarifies the level of detail returned, without contradicting any annotations.

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

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

The description is a single, well-structured sentence that front-loads the primary purpose and then compactly enumerates the content categories. Every word contributes meaningful information, with no redundancy or 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 get-by-id tool with one parameter and readOnly annotation, the description provides a solid overview of the returned data. It does not explain return format or error behavior, but given the low complexity and existing annotations, the description is sufficiently complete for an agent to understand the tool's purpose and output scope.

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 has one required parameter, property_id, with no description (schema_description_coverage = 0%). The description does not mention property_id at all, leaving the parameter semantics entirely to its self-explanatory name. Since the description is expected to compensate for missing schema descriptions, it fails to do so, though the parameter is simple.

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 resource ('bien immobilier') and the specific verb ('Retourne le détail complet'), enumerating included categories (characteristics, financial amounts, depreciable base, counts of related items). This distinguishes it from siblings like list_properties (which lists all properties) and other get_* tools for specific entities.

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

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

The description implies the tool is used when retrieving comprehensive details for a single property, but it does not explicitly state when to use it versus alternatives (e.g., list_properties for overviews, get_expense for specific financial entries). No exclusions or alternative tools are mentioned, so guidance is only implicit.

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 readOnlyHint=true already indicating a safe read operation, the description adds meaningful context by enumerating the exact return fields (gross income, results, advantage, recommendation, estimated savings) and clarifying that all amounts are in euros. This goes beyond the annotation without contradicting it.

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

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

The description is compact and front-loaded with the main purpose, followed by a structured list of return values. Every sentence provides useful information 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?

The description covers the tool's purpose and output list, which is helpful given no output schema. However, it lacks parameter details and fails to differentiate from the similar sibling tool, making it only partially complete for an agent to use it correctly.

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

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

Schema description coverage is 0%, and the description only indirectly references the 'year' parameter and possibly the 'abatement' parameter via the 50%/30% deduction. The 'abatement' parameter is never explicitly explained, leaving the agent to guess its valid values and effect.

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

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

The description clearly states the tool compares micro-BIC and real regimes for a given year and lists specific outputs. However, it does not explicitly differentiate from the sibling tool 'compare_micro_bic', so it stops short of a perfect 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?

No guidance is given on when to use this tool versus alternatives like 'compare_micro_bic'. The description implies a yearly simulation but provides no exclusions or scenarios where other tools would be more appropriate.

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

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

The description adds value beyond the destructiveHint annotation by specifying return values (imported/ignored counts and errors) and the base64 encoding requirement. It does not disclose potential side effects like overwriting, but the annotation already signals destructive potential, and the added output details are useful.

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

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

The description is two sentences, front-loaded with the main purpose, and contains no unnecessary detail. Every sentence contributes meaningful information about the tool's functionality and output.

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

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

The description covers the core import behavior, input encoding, and return values, which is helpful given no output schema. However, it omits the preview parameter entirely, which is significant because the destructiveHint suggests a potential dry-run capability. This leaves the tool's behavior incompletely 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?

The description explicitly explains csv_base64 (base64-encoded CSV content) and property_id (the target property) in context, but it does not mention the preview parameter. With 0% schema coverage, this leaves one parameter unexplained, so the description only partially compensates for the schema gap.

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

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

The description clearly states the tool imports Airbnb CSV files (transaction/reservation history) into a specific property, using a specific verb and resource. It distinguishes from sibling CRUD tools by being the only import operation.

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 on the expected use case and input requirements (base64 encoding), but it does not explicitly state when to use this tool over alternatives or any exclusions. Since there are no competing import tools, usage is implied rather than explicitly guided.

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

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

The readOnlyHint annotation already indicates a read-only operation, and the description adds context about the specific enum fields covered. It also notes the tool's importance for form completion, but does not describe return format or edge cases.

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

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

The description is two sentences, front-loaded with the core action and followed by a practical usage note. It is concise 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 parameterless read-only enumeration tool, the description fully covers what it does and when to use it. The lack of output schema is acceptable for such a simple tool, and the list of enum domains provides 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?

There are zero parameters, so the schema is fully covered at 100%. The description adds no parameter details but none are needed; baseline for 0 params is 4.

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 it returns all valid enum values for specified fields, using the verb 'Retourne' and listing the specific categories. It distinguishes itself from sibling list tools by focusing on enum metadata rather than records.

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 states it is 'Indispensable avant de créer un revenu ou une charge' (essential before creating an income or expense), giving a clear when-to-use. However, it does not mention when not to use or alternative 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?

The annotation readOnlyHint=true already signals a read-only operation, and the description's 'list' action is consistent. However, the description adds no additional behavioral context such as pagination, sorting, or response format. It does add the allowed category values, which is useful but not a behavioral trait. The description does not contradict annotations.

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

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

The description is a single sentence that states the core action and optional filters, followed by a concise list of valid categories. Every element is relevant and directly informative, with no wasted words.

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

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

Given the simple list operation, a read-only annotation, and a straightforward schema, the description covers the essentials: what is listed, the available filters, and valid categories. The output structure is not specified, but it is easily inferable for a list operation. No major gaps are present.

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

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

The schema provides three parameters (year, category, property_id) with no descriptions (0% coverage). The description compensates by mapping these to 'bien, année et catégorie' and by enumerating the valid category values (property_tax, insurance, etc.). It does not detail the year format or property_id semantics, but adds significant meaning beyond the bare 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 clearly identifies the tool's function: 'Liste les charges déductibles de l'utilisateur' with optional filters by property, year, and category. The verb 'list' and resource 'expenses' distinguish it from sibling tools like get_expense (single expense) and create_expense (creation).

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

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

The description implies use for listing expenses with optional filters, but does not explicitly contrast with alternatives like get_expense for individual expenses or create_expense for adding. No when-not-to-use or alternative references are provided, making the guidance 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?

The readOnlyHint annotation already signals a safe read operation. The description adds useful behavioral details beyond the annotation, such as the sort order (by year descending) and the specific fields included for each fiscal year (status, fiscal result, revenues, expenses, depreciation, capped depreciation, deficit carryforward). This enhances transparency without contradicting annotations.

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

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

The description is a single, focused sentence that front-loads the primary purpose and lists the returned data fields succinctly. Every word contributes value, with no filler or redundant 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 the tool's simplicity (no params, no output schema), the description fully covers what the agent needs to know: what the tool lists, how results are ordered, and what fields are included per fiscal year. There are no obvious gaps for invoking this tool correctly.

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

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

The tool has zero parameters, so the schema is trivially complete. The baseline for 0 params is 4; the description doesn't need to add parameter-specific semantics since there are none.

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 action (lists all fiscal years), the scope (user's fiscal years), and the sorting order (descending year). It distinguishes from sibling tools like get_fiscal_year, which targets a specific year, making the tool's purpose unambiguous.

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

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

The context for use is implicitly clear: this is the tool to list all fiscal years, as opposed to get_fiscal_year for a singleton. It doesn't explicitly name alternatives or exclusions, but the list-versus-get distinction is reasonable from the description alone.

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 readOnlyHint=true, the annotation already declares this as a safe read operation. The description adds useful context by specifying that it returns depreciable items only and lists the exact fields returned, going beyond the annotation. No contradictions found.

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

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

The description is a single sentence that front-loads the action and scope, then efficiently lists the return fields. No redundant wording or fluff, every part adds value.

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

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

For a simple read-only list tool with one optional parameter and no output schema, the description covers the purpose, optional filter, and return fields. This is sufficient for an agent to invoke the tool correctly without additional documentation.

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 has one parameter (property_id) with no description (0% coverage). The description compensates fully by explaining the optional property filter, making it clear that property_id filters results by a specific property. This is a direct mapping to the only 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 tool lists the user's depreciable furniture and equipment with an optional property filter. It uses a specific verb ('Liste') and resource ('mobilier et équipements amortissables'), distinguishing it from sibling write tools like create_furniture, update_furniture, and delete_furniture.

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

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

The description provides clear context for when to use the tool—when listing furniture/equipment—and mentions the optional property filter. It does not explicitly name alternative tools (e.g., list_properties) or state when not to use it, but the context is 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?

The readOnlyHint annotation already declares the safe read-only nature. The description adds value beyond that by specifying return contents: amounts in euros with VAT, platform fees, and tourist tax, plus the filterable dimensions. This gives the agent useful behavioral expectations.

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 states the action and optional filters, the second states what is returned. Every word earns its place, with no filler or redundancy.

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

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

For a read-only list tool with 3 optional parameters and no output schema, the description fully covers filter semantics and return payload. It mentions the available filters, allowed source values, and the currency plus tax components, which is sufficient for an agent to invoke it correctly.

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

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

Schema description coverage is 0%, so the description carries the burden. It effectively maps all three parameters: bien (property_id), année (year), and plateforme (source), and enumerates allowed source values (airbnb, booking, abritel, direct, other). This adds meaning beyond the bare 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 'Liste' with the resource 'recettes locatives' and immediately clarifies it's a list operation with optional filters. This distinguishes it from siblings like get_income (single item) and list_expenses (different resource).

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 it lists user rental incomes with optional filters, clearly implying when to use it for collection queries. It doesn't explicitly name alternatives or exclusions, but the context is clear enough for an agent to choose this tool over single-item getters or other list 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?

Annotations already declare readOnlyHint=true, and the description adds useful behavioral context by listing the exact fields returned for each loan (bank, capital, rate, duration, monthly payment, insurance, dates, estimated total cost). No side effects or contradictions are introduced; it enhances the annotated safety profile.

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 states the purpose and optional filter, the second enumerates the return fields. There is no redundancy or filler, making it easy to parse.

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 list endpoint with one optional parameter and no output schema, the description covers purpose, filtering, and return data comprehensively. The read-only annotation confirms safety, and sibling tool names aid differentiation, making this description sufficient for an agent to invoke it correctly.

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

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

With schema description coverage at 0%, the description fully compensates by explaining the sole parameter (property_id) as an optional filter by property. It also implies that omitting it returns all loans, which adds meaning beyond the schema's bare type definition.

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 precise verb 'Liste' and clearly identifies the resource ('emprunts immobiliers de l'utilisateur') with an optional filter by property. It also enumerates the return fields, distinguishing it from sibling tools like get_loan (singular) or compute_loan_schedule by making clear this is a collection operation.

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 the tool: to retrieve the user's real estate loans, optionally filtered by a property. It does not explicitly mention alternatives or exclusions, but the context is clear for a list operation versus a single-item fetch like get_loan.

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

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

The readOnlyHint annotation already signals a safe read operation. The description adds behavioral context by specifying the returned fields and that the data is scoped to the authenticated user, which is useful beyond the annotation. It does not mention pagination or ordering, but these are less critical for a zero-parameter list tool.

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

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

The description is a single, concise sentence that immediately states the tool's purpose and the key output fields. It is appropriately sized, front-loaded, and contains no 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?

Given the absence of an output schema, the description names specific key fields but does not exhaustively define the response structure. It covers essential information for an agent to decide whether to use this tool, though a bit more detail about the full property object would make it more complete.

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

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

The tool has no parameters, and the schema coverage is 100% by default. The description correctly does not need to explain parameters, so the baseline score of 4 applies.

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

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

The description clearly states that the tool lists all real estate properties belonging to the authenticated user, with specific key information (surface, acquisition price, share, rental type). This distinguishes it from sibling tools like get_property (single property) and other list_* tools.

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

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

The description provides clear context: use this tool to retrieve all properties for the authenticated user. However, it does not explicitly mention alternatives or exclusions, though the scope and purpose are clear enough to guide appropriate usage.

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

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

Annotations already provide readOnlyHint, and the description adds useful behavioral context: it specifies the returned fields (percentage, base, duration, annual depreciation) and the constraint that percentages sum to 100%. This goes beyond the annotation without contradicting it.

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

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

The description is two concise sentences, front-loaded with the main action and output details. No redundant content exists; 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 simple read-only list tool with no output schema, the description adequately explains what is returned and a key business rule. It lacks edge-case behavior (e.g., invalid property_id or empty lists), but overall it is sufficiently complete for this complexity.

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

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

The schema has 0% coverage, and the description never mentions the property_id parameter. While the name is somewhat self-explanatory, the description fails to clarify its role or format, leaving a gap for a single-parameter 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 clearly states it lists depreciation components for a property, using the specific verb 'Liste' and resource 'composants d'amortissement', distinguishing it from sibling tools like list_properties and compute_depreciation.

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 usage is implied—this is for retrieving depreciation components—but there is no explicit guidance on when to use it versus alternatives, nor any exclusions. The read-only nature is apparent from annotations, not the 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?

Annotations provide readOnlyHint: true, and the description adds context by specifying the scope (amortizable works) and the detailed return fields. It does not describe pagination or edge cases, but the read-only nature is well covered by annotations and further clarified by the description.

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 that front-load the action and then detail the return fields. Every word adds value, with no repetition of schema information or fluff.

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

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

With no output schema, the description carries the burden of explaining return values, which it does by listing key fields. It does not mention ordering, pagination, or error conditions, but given the simple nature of a list tool with one optional filter, it is largely complete.

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

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

The schema has one parameter (property_id) with zero description coverage. The description compensates by explaining it is an optional filter by property ('filtre optionnel par bien'), giving the parameter purpose and optionality. It does not go deeper into format or edge cases, but for a single optional parameter this is sufficient.

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 it lists depreciable property works with an optional property filter, and enumerates the returned fields. This distinguishes it from sibling tools like list_expenses and list_furniture.

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 listing property works, but does not explicitly state when to prefer this over alternatives or mention any exclusions. Context from sibling tools (create_property_work, update_property_work) makes the use case reasonably clear, but explicit guidance is missing.

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

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

The description adds valuable behavioral context beyond the destructiveHint annotation by clarifying that only provided fields are modified (partial update) and that amounts are in euros. This helps the agent understand the tool's behavior, though it does not disclose error handling or return value specifics.

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—and front-loaded with the primary action first. Every sentence adds meaningful information 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?

The tool has 9 parameters and no output schema, yet the description only covers the partial update concept and currency. It does not specify return behavior, error cases, or validation rules, leaving the agent without a complete picture of the tool's behavior.

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

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

With 0% schema description coverage, the description partially compensates by stating that only provided fields are updated and that amount is in euros. However, it does not explain the meaning of fields like category, tva_rate, is_dedicated, or recurring_type, leaving many parameters underspecified.

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 'updates an existing operating expense' (Met à jour une charge d'exploitation existante), identifying both the action (update) and the resource (expense). It distinguishes from siblings like create_expense and delete_expense by explicitly saying 'existing' and specifying partial update.

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 modifying an existing expense, and the partial update note clarifies when to use (to change specific fields). However, it does not explicitly state when not to use or provide alternative tools such as create_expense or delete_expense, so it falls short of full usage guidance.

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

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

Beyond the idempotentHint annotation, the description discloses key behaviors: partial updates (only provided fields modified), amount currency in euros, and automatic recalculation of annual depreciation when amount or duration changes. This adds valuable business logic 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?

Three concise sentences, front-loaded with the primary purpose, followed by two crucial behavioral details. 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?

The description covers the core update behavior and depreciation logic, but has gaps: no mention of return value, error handling, or semantics for most parameters. Given the tool has 8 parameters and no output schema, this is adequate but not complete.

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

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

With 0% schema description coverage, the description must compensate, but it only addresses amount (currency) and duration (recalculation trigger). The partial update statement implies all fields are optional, but it doesn't explain tva_rate, is_dedicated, purchase_date, is_second_hand, or description. Six of eight parameters remain undocumented semantically.

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 updates an existing furniture item, using a specific verb and resource. It distinguishes from create_furniture and delete_furniture, and the partial update note adds further specificity.

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 existing furniture items, contrasting with creation, and clarifies that only provided fields are changed. It doesn't explicitly name alternatives but gives enough contextual cues for an agent to decide.

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 destructiveHint: true already provided, the description adds valuable behavioral context: 'Seuls les champs fournis sont modifiés' (only provided fields are modified) and clarifies the amount unit in euros. This goes beyond the annotation without contradicting it.

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

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

The description is two concise sentences, front-loads the primary action, and contains zero filler. Every word adds value, making it an exemplar of brevity.

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 12-parameter schema, absence of an output schema, and only a destructiveHint annotation, the description is too thin. It fails to mention error handling, return values, permission requirements, or field-specific constraints, leaving significant gaps for an agent 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 description coverage is 0%, so the description must compensate. It only clarifies the 'amount' unit (euros) and the partial-update behavior affecting all fields. The remaining 11 parameters (e.g., tva_rate, tourist_tax, platform_fee) are left entirely to their self-explanatory names, which may not be sufficient.

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 action and target: 'Met à jour un revenu locatif existant' (updates an existing rental income). This specific verb+resource pairing distinguishes it from sibling tools like create_income, delete_income, and update_expense.

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

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

The description implies usage context ('existing' income, partial update) but does not explicitly state when to use this tool versus alternatives or provide exclusions. It lacks the explicit alternative naming seen in high-quality examples, so it remains at the implied 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?

The annotation includes idempotentHint: true, and the description adds valuable context beyond that: only provided fields are modified, and money/area units are specified. While it doesn't disclose error behavior or auth requirements, the added partial-update semantics and units are meaningful given the annotation presence.

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, front-loaded with the main purpose and followed by a necessary unit clarification. There is no fluff or redundancy, and every part earns its place.

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

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

Given the tool's high complexity (20 parameters, no output schema, sparse annotations), the description is far too brief to be complete. It fails to explain domain-specific fields (e.g., tva_regime, rental_type), value constraints, or any dependencies between parameters, leaving significant gaps for an AI 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 0%, so the description must compensate for documenting 20 parameters. The description only provides global unit guidance (euros, m²) and does not explain any specific parameter meanings, types, or constraints, leaving most parameters ambiguous.

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 updates an existing property ('Met à jour les champs d'un bien immobilier existant'), distinguishing it from other update tools (expense, income, etc.). The added note that only provided fields are modified ('Seuls les champs fournis sont modifiés') further clarifies the specific 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 specifies the tool is for existing properties and performs partial updates, which gives clear context for when to use it (vs. creating a property). However, it does not explicitly name alternatives or state when not to use it, so it stops short of full usage guidance.

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

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

Beyond the idempotentHint annotation, the description adds important behavioral details: only provided fields are modified, the amount is in euros, and annual depreciation is automatically recalculated if amount or duration change. This discloses side effects and units not inferable from the schema or annotations.

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

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

Three short, front-loaded sentences: the first states purpose, the second explains partial update, and the third gives unit and side effect. Every sentence earns its place with no redundant wording 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?

The description provides core facts for a partial update tool: purpose, partial update semantics, unit, and automatic recalculation. It doesn't detail return values (no output schema) or all parameter meanings, but the schema supplies parameter names. The coverage is adequate given the tool's moderate 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?

With 0% schema description coverage, the description must compensate for parameter meanings. It adds value by clarifying that amount is in euros and that duration_years impacts depreciation. However, other parameters (tva_rate, work_date, is_dedicated, description) remain unexplained, leaving significant gaps in understanding.

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 explicitly states 'Met à jour un poste de travaux immobiliers existant' (updates an existing real estate work item), using a specific verb and resource. It clearly distinguishes itself from sibling tools like create_property_work and delete_property_work by focusing on updating existing items.

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

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

The phrase 'Seuls les champs fournis sont modifiés (mise à jour partielle)' explains partial update behavior, giving clear context for when to use this tool. However, it doesn't explicitly mention alternatives or when not to use it, so it doesn't reach a 5.

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