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

Annotations cover the safety profile (readOnlyHint=false, destructiveHint=false, idempotentHint=false, openWorldHint=true), so the bar is lower. The description adds genuine traits beyond the annotations: the token is validated against the /me endpoint before insertion, and the first dossier is auto-activated. It does not spell out duplicate-creation or error behavior, but the two disclosed traits are meaningful extras.

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

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

Three short sentences, front-loaded with the core action and followed by behavioral notes. Nothing is padded, though the auto-activation sentence could be seen as a secondary detail rather than core purpose.

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?

An output schema exists, so return values need no explanation. The description covers token validation and first-dossier activation, which are the non-obvious behaviors. It omits what happens for subsequent dossiers and any error conditions, leaving a modest gap for a mutation tool.

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

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

Schema description coverage is 100%, so all four parameters (slug, name, notes, token) are already documented in the schema. The description only indirectly touches the token parameter via the /me verification note and adds no format or constraint details beyond the schema. Baseline 3 applies when the schema does the heavy lifting.

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

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

States a specific verb and resource: 'Ajoute un nouveau dossier comptable à la configuration.' An agent can immediately tell this creates a dossier. It stops short of naming sibling operations (remove/switch/list_dossier), but the additive verb makes the distinction reasonably clear on its own.

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

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

No guidance on when to use this versus pennylane_switch_dossier, pennylane_list_dossiers, or pennylane_current_dossier, and no prerequisites stated. The note about the first dossier becoming active is operational context, not usage routing. An agent gets no explicit when/when-not guidance.

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

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

Tool has no 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?

Tool has no description.

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?

Tool has no description.

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

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

Tool has no description.

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

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

Tool has no description.

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?

Tool has no 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?

Tool has no 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?

Tool has no description.

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?

Tool has no description.

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

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

Tool has no description.

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

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

Tool has no description.

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?

Tool has no 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?

Tool has no 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?

Tool has no description.

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?

Tool has no description.

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

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

Tool has no description.

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

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

Tool has no description.

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?

Tool has no 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?

Tool has no 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?

Tool has no description.

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?

Tool has no description.

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

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

Tool has no description.

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

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

Tool has no description.

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?

Tool has no 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?

Tool has no 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?

Tool has no description.

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?

Tool has no description.

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

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

Tool has no description.

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

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

Tool has no description.

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?

Tool has no 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?

Tool has no 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?

Tool has no description.

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?

Tool has no description.

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

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

Tool has no description.

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

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

Tool has no description.

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?

Tool has no 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?

Tool has no 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?

Tool has no description.

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?

Tool has no description.

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

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

Tool has no description.

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

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

Tool has no description.

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?

Tool has no 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?

Tool has no 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?

Tool has no description.

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?

Tool has no description.

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

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

Tool has no description.

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

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

Tool has no description.

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?

Tool has no 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?

With annotations already covering the mutation profile (readOnlyHint=false, idempotentHint=false, destructiveHint=false), the description adds genuinely new behavior: prefix-driven auto-creation of fournisseur (401) or client (411) accounts. It does not mention permission requirements or reversal, but the key side effect is disclosed.

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

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

Two short sentences, front-loaded with the core action followed by the notable side effect. No filler, though the prefix rule partly repeats the schema's number description.

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?

An output schema exists so return values need not be explained, and annotations plus 100% schema coverage carry most structured detail. The description supplies the non-obvious auto-creation behavior, leaving only minor gaps like permission prerequisites.

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

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

Schema description coverage is 100%, so the schema already documents all four parameters, including the exact 401/411 prefix rule. The description's prefix explanation duplicates the number parameter's own description, adding no syntax or format detail beyond it. Baseline 3 applies.

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

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

States a specific verb and resource ('Crée un nouveau compte dans le plan comptable'), which is unambiguous. It does not explicitly name the sibling create tools (create_supplier/create_customer) it borders, but the accounting-account domain is distinct enough for an agent to route correctly.

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

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

Usage is only implied: the prefix rules hint that creating a 401/411 account will spawn a supplier/customer, but it never says when to prefer this tool over pennylane_create_supplier or pennylane_create_customer, nor what prerequisites exist. No explicit when/when-not guidance.

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

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

Annotations already declare readOnlyHint=false, idempotentHint=false, destructiveHint=false and openWorldHint=true, so the write/non-idempotent profile is known. The description adds the genuinely non-obvious trait that the operation is asynchronous and requires a separate retrieval call, which is real context beyond the annotations; it stops short of covering duplicate-export behavior or permissions.

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, zero filler, with the core action stated first and the async follow-up second. Every clause earns its place.

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

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

An output schema exists so return values need not be explained, and annotations cover the safety profile. The description completes the picture by documenting the async create-then-fetch flow; only minor gaps remain around the mode parameter's practical effect and whether repeated calls create separate exports.

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

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

Schema description coverage is 100%, with mode, period_start and period_end all documented in the schema itself (including the 'in_line'/'in_column' values), so the baseline is 3. The description only implies period scoping and adds no syntax or constraint detail beyond the schema.

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

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

States a specific verb (Crée) and resource (export Grand Livre Analytique) scoped to a period, and explicitly names the sibling pennylane_get_agl_export, so an agent can distinguish creation from retrieval without opening either schema.

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

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

Gives clear workflow context: the export is asynchronous, so the caller must follow up with pennylane_get_agl_export to obtain the file. It does not state when NOT to use it (e.g. versus pennylane_create_fec_export) or any prerequisites, but the follow-up routing is 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=false, idempotentHint=false, openWorldHint=true, and destructiveHint=false, so the agent knows this is a non-idempotent mutation of external state. The description adds the 'recurring' nature but nothing about required permissions, validation/mode behavior, or side effects on the customer. No contradiction, but limited added value.

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

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

Two short sentences, purpose front-loaded before the requirements. The second sentence slightly restates schema-required fields, so it is not perfectly waste-free, but overall it is tight and readable.

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?

An output schema exists and schema coverage is 100%, so the description does not need to explain returns or parameter details. For an 8-parameter, nested-object creation tool it covers the essentials; only a hint about the mode default or validation flow is missing.

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

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

Schema description coverage is 100%, so the schema already documents every parameter (mode, label, start, customer_id, invoice_lines, payment_method, recurring_rule, payment_conditions). The description names the required fields, which lightly overlaps but adds no syntax or format detail beyond the schema. Baseline 3 applies.

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

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

States a specific verb and resource: 'Crée un nouvel abonnement de facturation récurrente' (creates a new recurring billing subscription). This clearly distinguishes it from the get/list/update subscription siblings via the create verb. No sibling is explicitly named, but the operation is unambiguous.

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

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

There is no when-to-use guidance or mention of alternatives (e.g., vs update_billing_subscription). The second sentence only enumerates required inputs ('un client, une date de début, une règle de récurrence et des lignes'), which is prerequisite information rather than usage direction.

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

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

Annotations already declare readOnlyHint=false, idempotentHint=false, openWorldHint=true, destructiveHint=false, so the mutation/safety profile is covered structurally. The description adds no behavioral context beyond the annotations (no auth requirements, no side effects, no idempotency note), so it neither strengthens nor contradicts them.

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

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

Two short sentences, front-loaded with the action, with the required-parameter note second. No filler, though the second sentence duplicates schema information.

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

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

An output schema exists so return values need not be described, and annotations cover the safety profile. However, for a creation tool the description omits where categories live (which group context), auth expectations, and how it relates to the sibling category-group tools, leaving it only minimally 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 description coverage is 100%, so all four parameters are already documented in the schema, including the direction enum-like values and analytical_code. The description only restates that label and category_group_id are required, which is redundant with the schema's required array.

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

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

States a specific verb and resource ('Crée une nouvelle catégorie analytique') with scoping ('dans un groupe'), so the agent can tell it apart from list_category/get_category/update_category. It does not explicitly differentiate from other create_* siblings, but among the category tools the create purpose is unambiguous.

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

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

No when-to-use guidance, no prerequisites, and no mention of alternatives such as link_categories or create_category_group. The only guidance is that label and group ID are mandatory, which is parameter information rather than usage context.

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

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

Annotations already declare readOnlyHint=false, openWorldHint=true, idempotentHint=false, and destructiveHint=false, so the safety profile is covered structurally. The description adds nothing beyond that: it doesn't state whether duplicate detection applies (relevant since idempotentHint=false), whether the SIREN/TVA are validated, or what the response contains – though the output schema exists so return format is covered. With annotations doing the heavy lifting, the description's near-total silence is a mild, not severe, gap.

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

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

Two short, front-loaded sentences: the action and entity type first, the required field second. No filler, padding, 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?

An output schema exists, so return values need not be explained, and annotations cover safety. What's missing for an 11-parameter creation tool in a multi-dossier system is context on tenant/dossier scoping, duplicate handling, and why the SIREN/TVA fields matter – enough to make this merely minimally viable rather than complete.

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

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

Schema description coverage is 100%, with every one of the 11 fields documented (e.g., reg_no as 'Numéro SIREN (9 chiffres)'), so the baseline is 3. The description's 'Le nom (raison sociale) est obligatoire' echoes what the schema already enforces via the required array and adds no format or constraint detail beyond it.

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

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

States a specific verb and resource ('Crée un nouveau client de type entreprise') and explicitly distinguishes itself from the sibling pennylane_create_individual_customer by naming the 'entreprise/société' type. An agent can route between the two customer-creation tools without opening either schema.

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

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

No guidance on when to use this versus pennylane_create_individual_customer or pennylane_create_supplier, and no mention of prerequisites (e.g., required dossier context, which matters given the multi-dossier sibling tools). The only usage-relevant statement is the required-field note, which the schema already enforces.

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 readOnly=false, destructive=false, idempotent=false and openWorld=true, so safety and mutation traits are covered. The description adds the behavioral fact that the invoice is created as a draft by default, which is useful context, but it discloses nothing about permissions, side effects, or lifecycle beyond the schema's own draft default.

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

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

Two short sentences with the purpose front-loaded and zero filler. It is appropriately sized for a create tool, though it could have been slightly more informative without bloat.

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?

An output schema exists, so return values need not be explained, and annotations cover the safety profile. Still, for a 7-parameter creation tool in a dense invoice lifecycle family, the description omits how this relates to finalize/mark-paid siblings, leaving the agent to infer the workflow.

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

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

Schema description coverage is 100%, so the baseline is 3. The description adds a genuine constraint not encoded in the schema: at least one invoice line is required (the invoice_lines array has no minItems). The restating of required fields mildly duplicates the schema's required list.

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

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

States a specific verb (Crée) and resource (facture client) plus a scope qualifier (brouillon par défaut), so the agent knows it produces a new invoice in draft state. It is clear but does not explicitly differentiate itself from sibling creators/invoice lifecycle tools like update_customer_invoice or finalize_customer_invoice.

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 lists prerequisites (a customer, a date, a deadline, at least one line) which implies when the tool is applicable, and 'brouillon par défaut' hints at the draft-then-finalize workflow. However, it names no alternative and gives no explicit when-not, e.g. it never points the agent to update_customer_invoice or finalize_customer_invoice.

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 the mutation profile (readOnlyHint=false, idempotentHint=false, openWorldHint=true), so the safety burden is partly lifted. The description adds the balance invariant (total debits = total credits) and the string-typed amounts, but the balance rule is duplicated verbatim in the ledger_entry_lines schema, so the incremental behavioral disclosure is modest; nothing about validation errors, permissions, or side effects is added.

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 lines, front-loaded with the purpose and then the single most important constraint. Nothing is padded, though the amount-format line partly duplicates the schema and the balance rule appears again in the schema.

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

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

An output schema exists, so return values need not be explained, and the full schema coverage limits what the description must carry. However, for a write tool that depends on externally discovered IDs (journal_id, ledger_account_id), the description gives no guidance on sourcing those values, leaving a real gap for correct invocation.

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

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

Schema description coverage is 100%, so the schema already documents all 7 parameters with examples. The description's only parameter-level note (amounts are strings, e.g. '1500.00') restates what the schema's debit/credit descriptions already say, adding no new semantics.

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

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

States a specific verb and resource: creating a new accounting entry ('écriture comptable') with its lines, which clearly separates it from the sibling read/update tools (pennylane_get_entry, pennylane_update_entry, pennylane_list_entries). Sibling names are not referenced explicitly, so it stops short of a 5.

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

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

No statement of when to use this versus alternatives, no prerequisites, and no pointer to how the required journal_id / ledger_account_id are obtained (e.g. via pennylane_list_journals or pennylane_list_accounts). The description only asserts what the tool does, not when to reach for it.

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

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

Annotations declare it non-read-only, non-idempotent, open-world and non-destructive, but say nothing about execution model. The description adds the key operational trait that the export is asynchronous and requires polling for a 'ready' status, which is genuinely new information. Permissions or retry behavior on repeat calls are not addressed.

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, zero filler, with the resource and its async nature front-loaded before the routing instruction. Every phrase carries information the agent needs.

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?

An output schema exists, so return values need not be explained, and the description covers the create-then-poll workflow adequately. It could note whether overlapping periods cause duplicates, but overall an agent has what it needs.

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

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

Schema description coverage is 100%, with both period_start and period_end carrying format guidance (YYYY-MM-DD), so the schema does the heavy lifting. The description only implies date-range scoping via 'pour une période' and adds no syntax or boundary details beyond that.

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

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

States a specific verb and resource ('Crée un export FEC') with the scope ('pour une période'). This cleanly distinguishes it from the sibling pennylane_get_fec_export, which retrieves rather than creates.

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?

Explicitly names the follow-up tool and the condition that triggers it ('utilisez pennylane_get_fec_export ... une fois le statut ready'), which is a clear usage path. It does not, however, distinguish this FEC export from the sibling pennylane_create_agl_export.

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 the safety profile (readOnlyHint=false, destructiveHint=false, idempotentHint=false, openWorldHint=true), so the bar is lower. The description adds no behavioral context beyond that framework—no side effects, auth requirements, or dossier scoping—and the required-field note merely restates the schema. Minimum viable.

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

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

Two short, front-loaded sentences with the core identity of the resource first. The second sentence restating the required fields is slightly redundant against the schema, keeping it short of a 5.

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

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

With a fully documented schema, a non-empty output schema, and annotations covering the safety profile, the description supplies the essential routing distinction (individual vs company). It is thin on when-to-use and dossier context, but nothing needed to invoke the tool correctly is missing.

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

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

Schema description coverage is 100%, so the schema documents all 10 parameters with titles and descriptions, making 3 the correct baseline. The description's mention that first_name/last_name are required adds nothing beyond the schema's required array.

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

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

States a specific verb ('Crée') and resource ('client de type particulier/personne physique'), and the parenthetical 'personne physique' cleanly distinguishes it from the sibling pennylane_create_company_customer. An agent can route individual-vs-company without opening either schema.

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

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

The description gives no when-to-use guidance, no prerequisites, and never names the alternative (pennylane_create_company_customer) or the condition that selects between them. Create context is only implied by the purpose, which matches the calibration case that scored 2.

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=false, idempotentHint=false, destructiveHint=false and openWorldHint=true, so the write/idempotency profile is covered. The description adds no behavioral context beyond that — no mention of duplicate-code errors, required permissions, or whether journals are scoped to the active dossier.

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

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

Two short sentences, purpose front-loaded, no filler. The code list is somewhat redundant with the schema's code parameter description, which keeps it from being fully economical.

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

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

For a two-parameter creation tool with an output schema and full annotation coverage, the definition provides enough to call it: purpose, required code/label, and conventional code values. Only multi-dossier scoping and duplicate handling are left unstated.

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

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

Schema description coverage is 100%, so the baseline is 3 for params the schema already documents. The description largely repeats the schema's own examples (VE, HA, BQ, OD) and only marginally extends them with PA (paie) and RB (reprise de balance), so real added value is small.

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

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

States a specific verb and resource ('Crée un nouveau journal comptable'), so the agent immediately knows this creates a chart-of-accounts journal. It does not name the sibling reads (pennylane_list_journals / pennylane_get_journal), but the verb choice makes the distinction self-evident.

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 when-to-use guidance is given: nothing about prerequisites (fiscal year/dossier context), when a new journal is warranted versus reusing an existing one, or what to do if the code already exists. The second sentence is about parameter values, not usage conditions.

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

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

Annotations already declare readOnlyHint=false, destructiveHint=false, idempotentHint=false and openWorldHint=true, so the safety profile is covered. The description adds no behavioral context beyond repeating the three required fields, saying nothing about side effects, permissions, or idempotency behavior.

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

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

Two short sentences, purpose front-loaded, with zero filler. Every sentence carries relevant information and the required-field note follows immediately.

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 rich schema (100% coverage), an output schema, and annotations covering the safety profile, the description covers purpose and required fields adequately. The only notable gap is the absence of guidance on when to choose this over sibling tools.

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

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

Schema description coverage is 100%, so the schema already documents all eight parameters, including VAT code examples and currency defaults. The description only confirms which three fields are required, which is already captured by the schema's required list.

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

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

States a specific verb and resource ('Crée un nouveau produit/service dans le catalogue'), which is clearly distinguishable from list/get/update_product siblings. It does not explicitly name those siblings, so it falls short of a 5.

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

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

No when-to-use guidance, no prerequisites, and no mention of alternatives such as pennylane_update_product or pennylane_get_product. Only the required fields are noted, which is schema information rather than usage context.

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

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

Annotations already declare readOnlyHint=false, idempotentHint=false, destructiveHint=false, and openWorldHint=true, so the safety profile is covered. The description adds the precondition that at least one line is required, which is a useful behavioral constraint not enforced by the schema, but it does not disclose permissions, side effects, or response behavior beyond that.

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

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

The description is two short sentences with no filler. It is front-loaded with the core action and then states the minimum required inputs, making it easy to parse quickly.

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

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

Given the rich schema (100% parameter descriptions), annotations covering safety, and an output schema, the description is largely sufficient for an agent to invoke the tool. It states the purpose and required preconditions, though it omits guidance on when to choose this tool over siblings.

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

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

Schema description coverage is 100%, so all nine parameters are documented in the schema itself. The description only restates the required parameters and adds no syntax, format, or default-value semantics beyond what the schema already provides.

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

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

The description states a specific verb and resource: 'Crée un nouveau devis' (creates a new quote). It clearly distinguishes creating a new quote from updating an existing one via the word 'nouveau', but it does not explicitly differentiate from siblings like pennylane_update_quote or pennylane_list_quotes.

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 only lists required inputs (customer, date, deadline, at least one line) rather than when to use this tool versus alternatives. There is no explicit guidance on when a new quote should be created instead of using pennylane_update_quote or other quote-related 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=false, openWorldHint=true, idempotentHint=false, and destructiveHint=false, so the mutation and non-idempotent profile is covered structurally. The description adds nothing beyond that (e.g., no warning about duplicate supplier creation, no side effects such as creating a linked account).

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

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

Two short sentences, front-loaded with the action and then the constraint. Nothing is padded, though the second sentence is redundant with the schema, so it is efficient rather than maximally informative.

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

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

An output schema exists and the input schema is fully documented, so return values and field formats are covered elsewhere. However, for an 11-parameter creation tool with optional business identifiers (IBAN, VAT, SIRET), the description provides no validation expectations, default behavior, or error conditions, leaving it only minimally 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 description coverage is 100% and all 11 parameters carry their own French descriptions (IBAN, SIREN, SIRET, TVA, payment_method values), so the schema does the heavy lifting. The description's only parameter remark is 'Le nom est obligatoire', which merely restates the required array; baseline 3 applies.

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

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

States a specific verb ('Crée') and resource ('un nouveau fournisseur'), so the operation is unambiguous. It does not need to distinguish itself from a sibling because no other tool creates suppliers, though it also offers no explicit contrast (e.g., vs. pennylane_list_suppliers or pennylane_update_supplier).

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

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

The description gives no context for when to use this tool versus alternatives, no prerequisites, and no indication of what happens on success. The only guidance is the required-field note, which is already enforced by the schema.

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

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

Annotations already declare readOnlyHint=true, idempotentHint=true, destructiveHint=false, and openWorldHint=true, so the safety profile is covered. The description adds that it returns connection information and uses the /me endpoint, but does not disclose auth requirements, rate limits, or other behavioral traits beyond what annotations provide.

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

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

A single, front-loaded sentence with no wasted words. The verb comes first, followed by the resource and scope, making it easy to parse quickly.

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

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

Given the tool is a zero-parameter read-only operation with an output schema and rich annotations, the description is nearly complete. It could add one sentence on when to choose it over similar dossier-listing tools, but otherwise nothing essential is missing 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 tool takes zero parameters, so there is no parameter semantics to clarify. Per calibration, a 0-param tool receives a baseline of 4 when the schema is empty and the description does not need to compensate.

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

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

States a specific verb ('Affiche') and resource ('dossier comptable actuellement actif') with additional scope ('informations de connexion Pennylane'). The 'currently active' qualifier implicitly distinguishes it from list-all siblings like pennylane_list_dossiers, but no sibling is named explicitly.

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

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

Usage is implied by the purpose: retrieve the active dossier and connection info. However, there is no explicit when-to-use guidance, no prerequisites, and no mention of alternatives such as pennylane_list_dossiers or pennylane_whoami.

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=false, idempotentHint=false and destructiveHint=false, so the safety profile is partly covered. The description adds genuinely new behavioral context beyond the annotations: the action is irreversible and the invoice acquires a definitive number. It does not mention auth requirements or exactly which fields become immutable, keeping it short of a 5.

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 tightly-scoped sentences with no filler. The purpose is front-loaded and the irreversibility warning is given immediately after, in an easy-to-spot position.

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 mutation with an output schema present, the description covers what the agent needs: what it does, that it is irreversible, and the numbering consequence. Minor gaps (auth/permission prerequisites, whether it can fail on an already-finalized invoice) remain but are non-blocking.

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

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

Schema description coverage is 100% and there is only one parameter, whose meaning ('identifiant de la facture brouillon') is fully documented in the schema. The description adds nothing about the id beyond what the schema already provides, so the baseline of 3 applies.

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

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

States a specific verb (transforme/finalise) and resource (brouillon de facture client → facture finalisée), making the state transition explicit. This clearly distinguishes it from the sibling create_customer_invoice and update_customer_invoice tools without opening either schema.

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

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

The description implies the trigger condition (you have a draft to finalize), but never names an alternative or states when-not to use it. There is no explicit routing against update_customer_invoice or mark_customer_invoice_paid, so usage is only implied.

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

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

The annotations already declare readOnlyHint=true, idempotentHint=true, destructiveHint=false, and openWorldHint=true, so the safety profile is fully covered. The description adds no additional behavioral context (no auth, error, or rate-limit notes), which is acceptable given the annotation coverage but earns no bonus.

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

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

A single, front-loaded sentence that states action, resource, and the required key with zero waste.

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

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

For a simple single-parameter read with an output schema present, the description need not explain return values, and the annotations carry safety. It is nearly complete, though it could have differentiated itself from the list sibling.

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

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

Schema description coverage is 100% and there is only one parameter whose meaning is fully documented in the schema. The description's 'par son identifiant' merely restates what the schema already says, adding no new formatting or lookup semantics.

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

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

States a specific verb and resource: 'Récupère le détail d'un compte comptable par son identifiant.' An agent can distinguish it from list_accounts, create_account, and update_account. It does not explicitly name the sibling alternatives, but the singular-retrieval semantics are clear.

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

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

Usage is only implied by the single-identifier semantics: fetch one account when its id is known. There is no explicit statement of when to prefer this over pennylane_list_accounts, nor any exclusion or prerequisite note.

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, idempotentHint, openWorldHint and destructiveHint=false, so the safety profile is covered. The description adds only the conditional-return behavior ("si prêt"), which usefully implies the export may not be ready yet, but it omits anything about auth, rate limits, or how long generation takes.

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

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

Two short sentences with zero padding; the core action is front-loaded and the conditional return detail follows immediately. Every sentence earns its place.

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

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

With an output schema present and annotations covering the safety profile, the description is nearly complete for a simple single-parameter read. The only minor gap is the absence of any explicit routing against sibling get/create export tools.

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 is a single parameter with 100% schema description coverage ("Identifiant de l'export AGL"), so the schema fully documents it. The description adds no further meaning about the id's format or origin, making the baseline 3 appropriate.

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

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

The description states a specific verb ("Récupère le détail") and resource ("export Grand Livre Analytique"), which is clearly distinguishable from the sibling pennylane_create_agl_export by the retrieval framing. It does not, however, explicitly name any alternative tool for contrast.

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

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

Usage is only implied: the note that it "Retourne le statut et l'URL de téléchargement si prêt" hints at polling for an asynchronously generated export, but there is no explicit statement of when to call this versus create_agl_export or get_fec_export, and no prerequisites 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?

Annotations already declare readOnlyHint, idempotentHint, destructiveHint=false and openWorldHint, so the safety profile is covered. The description adds only 'détail complet,' implying the full object is returned, but says nothing about auth requirements, error behavior for a missing id, or pagination/expansion semantics.

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

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

A single front-loaded sentence that names the action and the returned object with zero filler. Nothing could be removed without losing meaning.

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?

An output schema exists, so return values need no explanation, and the annotations cover the safety profile. For a one-parameter read tool this is largely complete; only failure behavior for an invalid id is unaddressed.

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

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

Schema coverage is 100% for the single 'id' parameter, whose meaning ('Identifiant de l'abonnement') is already documented in the schema. The description adds no format, type, or lookup-source detail beyond that, so the baseline 3 is correct.

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

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

States a specific verb ('Récupère') and resource ('le détail complet d'un abonnement de facturation'), which is enough for an agent to distinguish this retrieval-by-id tool from the list/create/update siblings even without naming them. No explicit sibling differentiation, so it stops short of a 5.

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

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

The description gives no when-to-use, when-not-to-use, or alternative-tool guidance. It does not say to prefer pennylane_list_billing_subscriptions when the id is unknown or pennylane_update_billing_subscription when modifying, leaving routing to inference from the name 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?

Annotations already declare readOnlyHint, idempotentHint, and destructiveHint=false, so the safety profile is covered structurally. The description adds nothing beyond that – no auth requirements, no note on behavior for a missing id, and no extra context – so it contributes little behavioral value.

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 with zero filler; the resource and the keying mechanism are both stated immediately.

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

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

For a low-complexity single-parameter read tool with full annotation coverage and an output schema, explaining return values is unnecessary. The description covers the essentials, though it could say a bit more to route agents between the several category-related siblings.

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

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

Schema description coverage is 100% and the id parameter is already documented as 'Identifiant de la catégorie.' The description's 'par son identifiant' merely restates the schema, adding no format or constraint details. Baseline 3 applies.

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

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

States a specific verb (Récupère) and resource (catégorie analytique) keyed by identifier, so an agent can tell it apart from pennylane_list_categories. However it does not explicitly distinguish itself from siblings like pennylane_get_category_group or pennylane_list_group_categories.

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

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

No guidance on when to use this versus pennylane_list_categories or pennylane_get_category_group, nor any prerequisites mentioned. The single-record-by-id usage is only implied by the phrase 'par son identifiant'.

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, idempotentHint=true, destructiveHint=false and openWorldHint=true, covering the safety profile. The description adds nothing beyond 'retrieve detail' – no note on auth, on what a category group contains, or on behavior when the id doesn't exist.

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

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

One short sentence with the verb, resource and lookup key front-loaded; there is no filler to remove.

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 an output schema present, return-value detail is unnecessary, and one parameter is fully documented. However, for a get-by-id tool sitting among list_category_groups and get_category, the description does nothing to disambiguate the resource, leaving a small gap.

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

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

Schema description coverage is 100% and there is a single required id parameter already documented as 'Identifiant du groupe de catégories.' The description's 'par son identifiant' merely restates it, so the baseline of 3 applies.

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

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

States a specific verb ('Récupère') and resource ('le détail d'un groupe de catégories') scoped by identifier, so an agent can distinguish it from pennylane_list_category_groups. It does not name the sibling explicitly, which keeps it short of a 5.

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

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

The phrase 'par son identifiant' implies the id must come from a prior list call, but no tool is named and there is no when/when-not guidance. The agent must infer that this is the detail-fetch counterpart to pennylane_list_category_groups.

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, idempotentHint and destructiveHint=false, so the safety profile is covered. The description adds that the response contains address, contacts and payment terms, which is light but relevant context; it says nothing about auth scope or missing-id behavior, so a 3 is appropriate.

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

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

Two short sentences, zero filler, with the action front-loaded and the return content following. 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?

With an output schema covering return values and rich annotations covering the safety profile, the description only needs to convey purpose and lookup key, which it does. A brief note on error behavior for an unknown id would make it fully complete.

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

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

Schema description coverage is 100% and there is a single, fully documented parameter, so the baseline is 3. The description only echoes 'par son identifiant' without adding format or constraint detail beyond the schema.

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

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

States a specific verb (Récupère) and resource (le détail d'un client) with the lookup key (par son identifiant), which cleanly separates it from the list_customers sibling. It does not explicitly name an alternative, so it falls short of a 5.

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

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

The phrase 'par son identifiant' implies the precondition that an id is already known, distinguishing it from list_customers, but the description never states when to use this versus listing or the changelog tools. Usage is implied rather than spelled out.

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 cover readOnly/idempotent/openWorld/non-destructive, so the description earns credit for adding response-shape behavior: invoice_lines, payments and matched_transactions are embedded rather than returned as URLs. It also discloses a non-obvious data semantic (empty lists = unreconciled), which annotations cannot convey.

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?

Front-loaded with purpose, then progressively adds embedding behavior and reconciliation semantics in three tight sentences. Every sentence adds distinct information and none is 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?

Output schema exists so return values need not be enumerated, and the description still supplies the one thing an agent would otherwise get wrong: that payments/matched_transactions are embedded and that empty lists do not mean the money has arrived. Combined with annotations covering safety, this is complete for a one-parameter getter.

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

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

Schema coverage is 100% and there is a single documented 'id' parameter, so the schema already carries the semantics. 'Par son identifiant' restates the schema without adding format, range or validity guidance, so the baseline 3 applies.

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

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

States a specific verb (récupère) and resource (facture client) with the lookup key (par son identifiant), and 'détail complet ... en un appel' implicitly separates it from the list_customer_invoices sibling. It never names an alternative explicitly, so it falls just short of full sibling differentiation.

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

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

Usage is implied by 'en un appel' (fetch everything in a single call) rather than stated as a when-to-use rule against list_customer_invoices or list_customer_invoice_lines. The note that empty payments/matched_transactions mean 'not reconciled, see Qonto' is a partial when-not hint, but no alternative tool in this family is named.

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, idempotentHint=true, and destructiveHint=false, so the safety profile is well covered. The description adds that the response includes all lines of the entry, which is useful behavioral context, but it does not disclose authentication needs, rate limits, or error behavior beyond that.

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

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

The description is a single, front-loaded sentence that efficiently conveys the core purpose and scope with zero wasted words.

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

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

For a simple getter with one documented parameter, full annotation coverage, and an output schema, the description is nearly complete. It could be improved by clarifying how it differs from list_entries or get_entry_line, but it does not omit anything essential 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 has 100% description coverage, with the single 'id' parameter clearly documented as the unique identifier of the entry. The description adds no additional syntax, format, or constraint details beyond what the schema already provides, so the baseline of 3 is appropriate.

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

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

The description states a specific verb ('Récupère') and resource ('écriture comptable') and clarifies scope by saying it returns the complete detail with all lines. However, it does not explicitly differentiate from siblings like list_entries or get_entry_line, leaving some ambiguity for an agent to resolve from tool names alone.

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

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

There is no guidance on when to use this tool versus alternatives such as list_entries or get_entry_line. The description only states what the tool does, not the conditions or context that should trigger its selection over similar 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?

Annotations already declare readOnlyHint=true, idempotentHint=true, destructiveHint=false, and openWorldHint=true, so the safety and idempotency profile is fully covered. The description adds nothing beyond that structured data, but with annotations carrying the burden, a 3 is appropriate.

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, efficient sentence that is front-loaded and free of waste. It is perhaps overly terse, but nothing is padding.

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

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

An output schema exists so return values need not be described, and annotations cover the safety profile. For a simple single-id getter this is minimally adequate, but the lack of sibling disambiguation leaves a small gap.

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

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

Schema description coverage is 100% for the single id parameter ('Identifiant unique de la ligne d'écriture'), so the schema fully documents the argument. The description adds no extra meaning such as format or sourcing of the id, giving the baseline 3.

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

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

States a specific verb (Récupère) and resource (le détail d'une ligne d'écriture comptable), so an agent knows this fetches a single entry line rather than the parent entry. However, it does not explicitly differentiate itself from siblings like pennylane_get_entry, pennylane_list_entry_lines, or pennylane_list_all_entry_lines, so it falls short of a 5.

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

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

The description provides no when-to-use guidance, no mention of alternatives (e.g. list_entry_lines for retrieving many lines), and no prerequisites. Usage is only implied by the tool name and verb.

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 cover the safety profile (readOnlyHint, idempotentHint, destructiveHint=false), so the description's real value is the extra behavioral detail it adds: the three status values and, critically, that the download URL expires in 10 minutes. That expiry constraint is non-obvious and materially affects how an agent should act.

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

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

Two short sentences, outcome-oriented and front-loaded: what it returns first, then the time-sensitive caveat. 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?

With an output schema present, the description need not enumerate return fields, and annotations cover safety. The added status/expiry detail makes it self-sufficient for a single-param read tool, though a hint about polling cadence or the create-then-get workflow would complete it.

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

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

Schema description coverage is 100% and the single 'id' parameter is already documented as 'Identifiant de l'export FEC.' The description adds no format or source guidance for the id, so the schema carries the load and 3 is the correct 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?

States a specific verb and resource ('Récupère le détail d'un export FEC'), so an agent can immediately tell it apart from the sibling pennylane_create_fec_export. It also summarizes the payload (status + download URL), though it does not explicitly name the sibling it is not.

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

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

The mention of a pending/ready/error status implicitly signals a polling use case after pennylane_create_fec_export, but no when-to-use, prerequisites, or alternative is stated explicitly. Usage is inferred rather than 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?

Annotations already declare readOnlyHint=true, idempotentHint=true, destructiveHint=false, and openWorldHint=true, so the safety profile is fully covered. The description adds no behavioral context beyond the annotations (no auth needs, rate limits, or error behavior), which is acceptable given annotation coverage but adds no value.

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

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

A single well-formed sentence with zero filler, front-loading the action and resource. Nothing needs trimming and nothing is buried.

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

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

For a simple one-parameter read with an output schema and full annotation coverage, the description supplies what an agent needs to call it. Only the lack of any link to the list_journals workflow keeps it from being fully 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 a single parameter at 100% schema description coverage, the schema already documents the id fully. The phrase "par son identifiant" merely echoes the schema's "Identifiant unique du journal" without adding format or source guidance, so the baseline 3 applies.

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

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

The description states a specific verb ("Récupère"), resource ("journal comptable"), and scope ("par son identifiant"), making the operation unambiguous. It implicitly contrasts with pennylane_list_journals by fetching a single detail record, but never names that sibling, so it falls short of full differentiation.

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

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

There is no when-to-use, when-not, or alternative guidance. The description only restates that an identifier is required, leaving the agent to infer that this is the single-record counterpart of list_journals without any explicit routing.

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

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

Annotations already declare readOnlyHint=true, idempotentHint=true, and destructiveHint=false, so the safety profile is covered. The description adds the returned field set (libellé, prix HT, TVA, unité, compte comptable), which is mild added context, but it discloses nothing about error behavior, missing-id handling, or permissions.

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

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

Two short sentences, front-loaded with the action and resource. The second line listing return fields is somewhat redundant with the existing output schema, keeping it just below a 5.

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

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

For a simple read-only, single-id retrieval with rich annotations and an output schema, the description is essentially complete. Since the output schema exists, the return-field enumeration is a bonus rather than a requirement, so nothing critical is missing.

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

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

Schema description coverage is 100% and the single 'id' parameter is documented in the schema as 'Identifiant unique du produit', so the description adds no new parameter meaning. Baseline 3 is appropriate when the schema does the work.

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

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

States a specific verb and resource ('Récupère le détail d'un produit par son identifiant'), which clearly differentiates it from the list/create/update product siblings by naming the identifier-based detail retrieval. It is clear but does not explicitly name an alternative like pennylane_list_products for enumeration.

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

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

Usage is only implied: the agent must infer it should have an id (presumably from pennylane_list_products) and that this is the single-record lookup versus the list tool. No explicit when-to-use or when-not-to-use guidance is given.

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

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

Annotations already declare readOnlyHint=true, idempotentHint=true, destructiveHint=false and openWorldHint=true, so safety behavior is fully covered structurally. The description only adds that the full detail (amounts, lines, status, customer) is returned, which is largely redundant given an output schema exists; it says nothing about errors or auth.

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

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

Two short sentences, front-loaded with the action and the identifier, with no wasted words. The second sentence's field list is slightly redundant against the output schema but does not bloat the text.

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

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

For a single-argument read tool with rich annotations and a dedicated output schema, the description covers what the tool does and what it returns. Nothing critical is missing, though an explicit sibling reference would round it out.

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

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

Schema description coverage is 100% for the single required 'id' parameter, so the schema itself documents the argument. The phrase 'par son identifiant' merely restates the id parameter without adding format, range, or lookup semantics. Baseline 3 applies.

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

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

States a specific verb (récupère) and resource (devis) scoped to retrieval by identifier, and enumerates the returned fields (montants, lignes, statut, client). It is easy to distinguish from list_quotes/create_quote/update_quote, but it never names a sibling explicitly to reinforce the routing.

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

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

Usage is implied: to fetch a single quote you already know the id of. There is no explicit when-to-use vs. pennylane_list_quotes or pennylane_list_quote_lines, and no stated preconditions (e.g. needed permissions or whether the quote must exist).

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, idempotentHint=true and destructiveHint=false, so the safety profile is covered externally. The description adds that a full supplier record is returned (address, SIRET, IBAN, payment terms), which is useful but overlaps heavily with the output schema that already exists.

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

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

Two short sentences, zero filler, with the primary action front-loaded and the returned-field detail following. Nothing to trim.

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

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

Given a 1-param schema at full coverage, an output schema, and annotations covering the safety/idempotency profile, the description is nearly complete. A brief note on error behavior for a non-existent id is the only meaningful gap.

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

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

Schema coverage is 100% and there is a single parameter whose schema description already explains it as the supplier's unique identifier. The description's 'par son identifiant' merely restates the schema, so this is baseline territory.

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

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

States a specific verb and resource ('Récupère le détail d'un fournisseur') and scopes it to a single record via 'par son identifiant', which cleanly separates it from the list/create/update siblings. It doesn't explicitly name those siblings, so it falls short of a 5.

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

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

The use case (fetch one supplier by id) is implied by the identifier-scoping, but there is no explicit when-to-use vs. when-to-use-list guidance and no mention of alternatives. Adequate but leaves routing inference to the agent.

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

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

Annotations already declare readOnlyHint, idempotentHint and destructiveHint=false, so the safety profile is fully covered structurally. The description adds value by enumerating what the detail payload contains (montants, lignes, statut, fournisseur), hinting it aggregates line-level data, but says nothing about auth scope, pagination or error behavior.

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

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

Two short sentences, zero waste, and the core action is front-loaded ahead of the return summary. Nothing superfluous.

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 read tool with an output schema and full annotation coverage, the description is nearly sufficient on its own; it even summarizes the return contents. Minor gap is the absence of any routing hint to the list or line-level siblings.

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?

Only one parameter, and schema description coverage is 100% ('Identifiant unique de la facture fournisseur'), so the schema already carries full meaning. The description adds no syntax or format detail for the id, making the baseline 3 appropriate.

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

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

States a specific verb and resource ('Récupère le détail complet d'une facture fournisseur'), clearly distinguishing a single-record fetch from the sibling list_supplier_invoices. It does not explicitly name the alternative, but the verb 'get/récupère' plus 'détail complet' makes the singular-fetch intent 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?

Usage is implied by the 'get one by id' pattern shared with pennylane_get_customer_invoice, pennylane_get_supplier, etc. There is no explicit when-to-use vs list_supplier_invoices or when-not guidance, so the agent must infer the selection rule from the name 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?

Annotations already declare readOnly, idempotent, and non-destructive, so the safety profile is covered. The description adds genuinely useful behavior beyond that: automatic pagination across all accounts (classes 1-7) and handling of auxiliary accounts, which tells the agent the result is a complete, exact total rather than a page.

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

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

Two short paragraphs with the core action front-loaded and pagination detail second. Efficient, though the 'TOUS les comptes' emphasis is slightly redundant with the schema's own 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?

An output schema exists, so return values need not be explained, and annotations carry the safety profile; the description covers purpose, use contexts, and pagination behavior. It is complete for a read-only report tool, with only minor redundancy rather than a real gap.

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

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

Schema description coverage is 100%, so the schema already documents period_start, period_end, and the is_auxiliary filter including its default behavior. The description's note about classes 1-7 largely restates what the schema says, adding only marginal meaning over the structured fields, so the baseline of 3 applies.

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

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

States a specific verb ('Récupère') and resource ('balance générale') plus the returned content ('chaque compte avec ses totaux débit/crédit'). The purpose is unambiguous, but the description does not explicitly name or contrast against siblings like pennylane_list_accounts or pennylane_list_entries, so it stays at 4.

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?

Explicitly names the use contexts: closing work ('travaux de clôture'), balance verification ('vérification des soldes'), and financial statement preparation. That gives clear when-to-use guidance, but there are no exclusions or named alternatives for when a different tool (e.g., list_entries) is preferable.

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=false, idempotentHint=false, destructiveHint=false and openWorldHint=true. The description adds the operational constraints an agent needs: lines must share the same account (e.g. 411xxx), and the default requires total debit = total credit. It does not say how to reverse the operation, which is the main remaining gap.

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

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

Four short sentences, front-loaded with what the tool does, then the use case, then constraints. No filler, though the parenthetical 'rapproche' is a minor redundancy with 'lettre'.

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 an output schema present, the description needn't explain returns. It covers purpose, use case, account constraint and balance default, which is nearly everything needed; the only omissions are the reversibility path and the account-type restriction for other account classes.

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

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

Schema coverage is 100% so the schema already documents both parameters, but the description adds meaning to allow_partial by explaining the default balancing rule (total debit = total credit) that the flag relaxes.

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

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

States a specific verb and resource: lettering (reconciling) entry lines with each other, and clarifies the practical goal of matching invoices to payments. An agent can distinguish this from unletter_lines, but the description does not name the sibling it is complementary to.

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

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

Gives implied usage context ('permet de pointer des factures avec des règlements') and prerequisites (same account, balanced by default), but never explicitly says when to prefer this over unletter_lines or list_lettered_lines, nor when not to use it.

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

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

Annotations already declare the operation is a non-read-only, idempotent, non-destructive, open-world mutation. The description adds only the weight constraint (0–1, sum=1), which is not behavioral context beyond the schema. No auth, rate-limit, or side-effect detail is given, but the annotation coverage lowers the bar.

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

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

Two short sentences, front-loaded with the core action and no filler. The second sentence duplicates a schema constraint rather than adding new information, keeping it just below maximum efficiency.

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 an output schema present and annotations covering the safety profile, the main gaps are the absence of when-to-use guidance and any failure/edge-case notes. Adequate for a simple two-parameter tool but not fully self-sufficient.

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

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

Schema description coverage is 100%, so both line_id and categories are fully documented in the schema. The description restates the weight rule but adds no syntax or format detail beyond what the schema already provides, warranting the baseline 3.

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

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

The description states a specific verb and resources: 'Associe des catégories analytiques à une ligne d'écriture' (associates analytical categories to an entry line). This distinguishes it reasonably from listing siblings like pennylane_list_line_categories, though it does not explicitly name or contrast with any sibling.

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

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

There is no when-to-use guidance, no mention of prerequisites, and no alternatives offered. The agent must infer that this is the tool for attaching categories to a line versus the list/get variants in the sibling set.

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, idempotentHint=true, destructiveHint=false, and openWorldHint=true. The description adds that the operation supports filters and pagination, which is useful context, but it does not disclose anything further about permissions, rate limits, or what filtering defaults (e.g., enabled_only) mean behaviorally. With annotations covering the safety profile, this is adequate but not rich.

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

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

Two sentences with no wasted words. The tool's core function is front-loaded, and the second sentence provides immediately useful prefix examples without sprawling into unrelated detail.

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

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

For a read-only list tool with 5 fully documented parameters, rich annotations, and an output schema, the description covers purpose and usage well. It does not explicitly mention when to choose pennylane_get_account instead, but the gap is minor given the schema and annotations already carry the rest of the load.

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

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

Schema description coverage is 100%, and the description's prefix examples largely repeat what is already in the number_prefix parameter description (e.g., '411' clients, '401' fournisseurs, '512' banque). It adds only the extra examples '6=charges, 7=produits', so the schema does the heavy lifting and baseline 3 is appropriate.

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

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

States a specific verb ('Liste') and resource ('comptes du plan comptable') and scopes it with 'filtres et pagination'. The singular counterparts in the sibling list (pennylane_get_account, pennylane_create_account, pennylane_update_account) are implicitly distinguished by the plural list verb, so an agent can tell what this tool does without opening the schema.

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

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

Provides concrete usage contexts: consulting the chart of accounts and searching by account-number prefix, with real examples (411=clients, 401=fournisseurs, 512=banque). It does not explicitly name alternatives such as pennylane_get_account for a single account or state when not to use this tool, so it falls short of a 5.

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

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

Annotations already declare readOnlyHint, idempotentHint, destructiveHint=false and openWorldHint, fully covering the safety profile. The description adds the filter dimensions but nothing about pagination behavior, result volume, or how the 'all vs scoped' retrieval differs from the sibling — so it adds only marginal behavioral context.

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

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

Two tight sentences with the purpose front-loaded and no filler. The usage clause is a slight add-on but still 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?

With an output schema present, return values need not be described, and all 7 optional params are covered by the schema. The one remaining gap is failure to disambiguate from the pennylane_list_entry_lines sibling, but otherwise the definition is sufficient for a low-complexity list tool.

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

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

Schema description coverage is 100%, so each parameter (sort, limit, cursor, date_from/to, journal_id, ledger_account_id) is already documented in the schema. The description only restates the journal/account/period filter groups, adding no syntax or format detail beyond the schema; baseline 3 is appropriate.

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

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

States a clear verb (Liste) and resource (lignes d'écriture comptable) plus the filter dimensions, so an agent knows this is a filtered bulk-listing tool. However, it never distinguishes itself from the near-identical sibling pennylane_list_entry_lines, leaving the 'all vs scoped' boundary ambiguous.

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 second sentence ('Utile pour analyser les mouvements d'un compte ou d'un journal sur une période') gives an implied use context, but there is no explicit when-to-use/when-not guidance and no mention of the competing siblings list_entry_lines, get_entry_line, or list_entries.

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, idempotentHint, destructiveHint=false and openWorldHint, so the safety profile is fully covered. The description adds that results are filterable and paginated, but pagination is already evident from the cursor/limit parameters, so it contributes little beyond structured data.

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

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

Two short sentences with the purpose front-loaded and no filler. Efficient, though the second sentence is somewhat redundant with the first.

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?

An output schema exists, all parameters are documented, and annotations cover the safety and idempotency profile. For a read-only list tool, nothing an agent needs to call it correctly is missing.

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

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

Schema description coverage is 100%, so all five parameters (sort, limit, cursor, status, customer_id) are already documented in the schema. The description only gestures at 'filtres' and 'statut/client' without adding format or syntax detail, which is the expected baseline when the schema does the heavy lifting.

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

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

States a specific verb ('Liste') and resource ('abonnements de facturation récurrente') and notes that filters and pagination are supported. It does not explicitly distinguish itself from siblings like pennylane_get_billing_subscription or pennylane_list_subscription_lines, but the scope is unambiguous.

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

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

'Utile pour consulter les abonnements actifs, filtrer par client ou statut' gives implied usage context. However it offers no explicit when-to-use alternatives (e.g., use get_billing_subscription for a single record, or list_subscription_lines for line detail), so routing 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?

Annotations already declare readOnlyHint=true, idempotentHint=true, destructiveHint=false and openWorldHint=true, so the safety profile is fully covered without the description. The description adds only that results are filtered and paginated, which is a minor behavioral note and largely duplicates what the schema's limit/cursor parameters already convey.

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

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

Two short sentences, front-loaded with the operation and free of filler. The second sentence is mildly redundant with the first since it restates the same purpose rather than adding new 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?

With an output schema present, return values need not be explained, and annotations cover the read-only/idempotent profile, so the description is nearly sufficient for a simple list endpoint. The remaining gap is disambiguation from the many sibling category tools, which an agent would still have to resolve on its own.

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

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

Schema description coverage is 100%, so all four parameters (sort, limit, cursor, category_group_id) are already documented with defaults and bounds. The phrase 'avec filtres et pagination' adds no syntax or semantics beyond what the schema states, making the baseline 3 correct.

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

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

The description names a specific verb and resource ('Liste les catégories analytiques'), so the operation is immediately identifiable. However, it does not differentiate this tool from close siblings such as pennylane_list_group_categories, pennylane_list_category_groups, pennylane_list_line_categories, or pennylane_get_category, so an agent must guess which category-listing tool is the right one.

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 second sentence ('Utile pour consulter les axes analytiques disponibles') implies the use case but gives no explicit when-to-use rule, no prerequisites, and never names an alternative tool for a related need. Usage is only inferable.

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, idempotentHint, destructiveHint=false and openWorldHint, so the safety profile is covered. The description adds domain context about analytical allocation but says nothing about pagination behaviour or result volume that the annotations do not already imply.

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

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

Two short sentences, front-loaded with the action and object, with no filler. The second sentence is explanatory rather than essential, but it is brief and earns its place as domain context.

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

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

For a simple paginated read-only list tool with an output schema and full annotation coverage, the description is sufficient. Return shape is handled by the output schema and pagination parameters by the input schema; nothing critical for correct invocation is missing.

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

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

Schema description coverage is 100%, so limit and cursor are already fully documented in the schema. The description adds no additional meaning about parameter behaviour, which is the expected baseline when the schema does the heavy lifting.

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

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

States a specific verb ('Liste') and resource ('groupes de catégories analytiques'), and the second sentence clarifies what a group contains. It does not explicitly distinguish itself from nearby siblings such as pennylane_list_group_categories or pennylane_list_categories, so sibling differentiation is left to the reader.

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

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

The listing intent implies this is the entry point for enumerating category groups, but there is no explicit when-to-use guidance or statement of when to prefer pennylane_list_group_categories or pennylane_get_category_group instead. Usage is inferred rather than directed.

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 readOnlyHint, idempotentHint, openWorldHint and destructiveHint=false, so the safety profile is fully covered. The description adds no behavioral context beyond that (no pagination behavior, no note that the required invoice id must reference an existing customer invoice), so there is little extra disclosure to credit.

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 short sentence that front-loads the verb and resource with no filler. It is appropriately sized, though it is terse enough that it leaves obvious gaps unaddressed.

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 a full output schema, rich annotations and 100% parameter coverage, the description only needs to carry purpose and routing. Purpose is clear, but the missing usage/routing guidance against sibling line-list tools leaves a modest gap, making this minimally adequate rather than complete.

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

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

Schema description coverage is 100%, with limit, cursor and customer_invoice_id each documented in the schema itself. The description's parenthetical "(articles)" slightly clarifies what a line is, but it adds no format, range or pagination detail beyond the schema, so the baseline of 3 applies.

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

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

The description gives a specific verb ("Liste") and resource ("les lignes (articles) d'une facture client"), clearly distinguishing the line-item view from the invoice-header view of the sibling pennylane_list_customer_invoices. It also scopes to "client" invoices versus the supplier-invoice-line sibling, though it never names those siblings explicitly.

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

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

There is no when-to-use or when-not-to-use guidance. The agent is left to infer that this is the drill-down from pennylane_list_customer_invoices or pennylane_get_customer_invoice, and no alternative is mentioned for retrieving invoice-level rather than line-level data.

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 cover read-only, idempotent, non-destructive, and open-world hints. The description goes further by disclosing compact-mode default, local filtering pagination behavior (1000-document cap, is_complete indicator, ignored limit/cursor), and the critical caveat that the paid field is unreliable and only status and remaining_amount_with_tax should be trusted.

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

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

The description is front-loaded with the main purpose and organized into clear paragraphs. It is somewhat lengthy, but every sentence conveys necessary nuance about filtering and semantics, so it earns its place without excessive 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?

Given 10 parameters, 100% schema coverage, an output schema, and rich annotations, the description fills the remaining gaps: local versus server-side filtering behavior, pagination side effects, and the ambiguous meaning of 'paid' and 'unpaid'. Nothing essential for correct invocation appears to be missing.

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

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

Schema description coverage is 100%, so the baseline is 3. The description adds meaningful context by grouping parameters into server-side versus local filtering and explaining the consequences for pagination, which goes beyond the schema's individual parameter descriptions.

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

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

Clearly states it lists customer invoices, including credit notes with negative amounts, in a compact mode by default. The verb+resource are unambiguous, but it does not explicitly name sibling alternatives such as get_customer_invoice or list_supplier_invoices to help an agent disambiguate in every case.

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

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

Explains which filters are applied server-side versus locally, and notes that local filtering forces full pagination while limit and cursor are ignored. It also clarifies that 'unpaid' means not reconciled in Pennylane and points to Qonto for actual cash arrival, giving useful context but not explicit when-to-use-vs-alternatives 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 declare readOnlyHint, idempotentHint, destructiveHint=false and openWorldHint, so the safety profile is fully covered by structured data. The description adds only that results are filtered and paginated, which is mild extra context; it says nothing the annotations don't about permissions or result behavior.

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

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

Two short sentences with the core action front-loaded and no wasted preamble. The second sentence is slightly generic ('consulter la base clients') but still earns its place as usage hint.

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 an output schema present, rich annotations and full parameter documentation, the description needn't explain return values or safety. It is complete enough to call the tool correctly; the only gap is routing versus sibling list/get tools.

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

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

Schema description coverage is 100%, so the baseline is 3. The description alludes to filters and pagination but adds no syntax, defaults or enum detail beyond what each schema property already documents (name, sort, limit, cursor, customer_type).

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

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

States a specific verb ('Liste') and resource ('clients'), and even scopes the resource to companies and individuals. It does not explicitly contrast itself with sibling list/get pairs such as pennylane_get_customer or pennylane_list_suppliers, so it stops short of full differentiation.

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

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

'Utile pour consulter la base clients, rechercher un client par nom ou type' implies usage context but gives no explicit when-not guidance or named alternative (e.g. use get_customer for a single record, list_suppliers for the other side of the ledger). Usage is inferable but never spelled out.

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, idempotentHint=true and destructiveHint=false, so the safety profile is covered. The description adds a genuinely useful behavioral fact beyond annotations – that tokens are masked for security in the output – but little else.

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

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

Two short sentences, front-loaded with the core action and with zero filler. Every clause earns its place.

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

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

With an output schema present, the return values need not be described, and the description still notes status and token masking. For a zero-argument list tool this is close to complete; only routing guidance versus sibling dossier tools is absent.

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 takes zero parameters, so the schema carries none of the semantic burden and the baseline of 4 applies. No parameter explanation is required.

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

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

States a specific verb and resource ('Liste tous les dossiers comptables configurés') and adds scope detail about status and token masking. It is clearly distinguishable from siblings like switch_dossier or current_dossier, though it does not explicitly name them.

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

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

Usage is implied by the operation itself (enumeration of configured dossiers), but there is no explicit when-to-use guidance or reference to sibling tools such as pennylane_current_dossier or pennylane_multi_dossier_query.

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