OutilsIA — Conseiller IA locale

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

Annotations already declare readOnlyHint=true and destructiveHint=false. The description adds valuable context: 'ne donne aucun accès à la machine' (no machine access) and the strict URL format requirement. This goes beyond what annotations provide, clarifying security and input constraints.

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

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

The description is two concise sentences in French, front-loaded with the action. Every word adds value, and there is no redundant or vague phrasing. It is well-structured and to the point.

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 presence of an output schema (no need to describe returns) and two parameters, the description covers the core purpose, URL constraint, and security. However, the missing description of the 'usage' parameter is a notable gap that reduces completeness for a tool with a dropdown enum. The description is adequate but not fully comprehensive.

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

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

With 0% schema description coverage, the description must explain parameters. It partially covers 'report_url' by specifying the exact URL format, but completely omits the 'usage' parameter (enum with 7 values and a default). The agent has no guidance on what 'usage' controls or how to set it, leaving a significant gap.

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

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

The description clearly states the action ('Lit un rapport public') and the specific resource ('OutilsIA Local Cockpit déjà créé par l'utilisateur'). It specifies the exact URL format, distinguishing it from sibling tools that list or explain parts of a report.

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

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

The description implies usage when the user has an existing report URL and wants to read it. However, it does not explicitly state when not to use this tool or mention alternative tools (e.g., listing models or benchmarks from the report instead). The statement 'Accepte uniquement une URL exacte' offers some guidance but lacks completeness.

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

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

Annotations already provide readOnlyHint and destructiveHint, signaling a safe read operation. The description adds behavioral context: it is not a scan and only uses provided characteristics, which clarifies the tool's limitations beyond what annotations convey. No contradictions.

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

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

The description is two sentences, front-loaded with the primary purpose and a guardrail. It wastes no words but omits essential parameter detail; however, conciseness is achieved given the limited scope of what is described.

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?

Despite the complexity of 10 parameters and an output schema, the description is incomplete: it lacks parameter explanations, output format (though output schema exists), and any guidance for sibling differentiation. The tool has a read-only annotation but the description doesn't leverage that to reduce burden; it leaves significant gaps for an agent.

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

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

Schema description coverage is 0% and the description offers no explanation of the 10 parameters, their meanings, or defaults. For example, the 'usage' enum values (e.g., 'polyvalent', 'code') are not defined, and fields like 'unified_memory' or 'cpu_cores' have no context. The agent has no guidance on how to fill these parameters correctly.

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

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

The description clearly states the tool's purpose: estimating which local AI models are suitable based on explicitly provided hardware characteristics. It differentiates from siblings by implying this is a compatibility check based on user-provided specs, not a scan or budget-driven recommendation.

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

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

The description explicitly says the tool should not be called if CPU, RAM, GPU, and VRAM are missing, providing a clear precondition. However, it does not guide the agent on when to choose this tool over sibling tools like 'list_models_for_budget' or 'recommend_runtime', leaving situational use ambiguous.

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

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

Annotations already declare readOnlyHint=true and destructiveHint=false, so the description's job is lighter. The description adds value by stating 'not a scan' (behavioral mode) and describing the input method. No contradictions with annotations. Some behavioral context (e.g., what happens with incomplete data) is missing but acceptable given the annotations.

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

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

Two short sentences, front-loaded with the core action and input instruction. Every word earns its place; no redundancy or filler. Ideal conciseness for a tool with a straightforward 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?

Given 8 parameters (none required, many optional) and an output schema, the description only covers the minimal input scenario. It does not explain the role of the other parameters (cpu_name, gpu_name, etc.) or how they interact. The output schema exists, so return values need not be described, but the input semantics are incomplete.

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

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

Schema description coverage is 0%, so the description must compensate. It mentions only 3 of 8 parameters (report_url, ram_gb, vram_gb) and gives partial semantics (alternative inputs). The other 5 parameters are unmentioned, leaving the agent to infer their role or ignore them. This is insufficient compensation for the low coverage.

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

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

The description clearly states the tool identifies a bottleneck from a report or RAM/VRAM profile, using a specific verb ('identifies') and resource ('bottleneck'), and clarifies it's not a scan. However, it does not explicitly distinguish itself from sibling tools like 'analyze_shared_report' or 'check_pc_for_local_ai', which could overlap in purpose.

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

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

The description instructs to provide either 'report_url' or 'ram_gb' and 'vram_gb', which gives clear entry conditions. The note 'not a scan' implies it should not be used for scanning. However, no explicit when-not-to-use or alternatives to sibling tools are provided.

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

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

Annotations already provide readOnlyHint: true and destructiveHint: false, making the read-only nature clear. The description adds valuable behavioral context beyond annotations: it confirms this tool never accesses the machine and performs no action, and states the return is the complete response in read-only mode. It also warns against adding any follow-up actions, which is not in annotations.

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

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

The description is two sentences: the first defines the trigger conditions precisely, the second sets strict post-call behavior rules. No wasted words; every sentence is necessary and front-loaded with critical usage conditions.

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

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

Given the tool has 2 optional parameters, a full output schema (not provided but exists per context), and comprehensive annotations, the description is fully self-contained. It explains purpose, triggers, safety profile (read-only, no machine access), and post-call constraints. No gaps remain for the agent to infer incorrectly.

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

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

Schema description coverage is 0%, so the description must compensate. While the description does not explicitly list parameter names or formats, it implies 'target' refers to what to install/scan/delete (e.g., Ollama, model, driver) and 'requested_action' maps to the listed actions (install, download, etc.). The description's trigger list directly corresponds to the action enum, providing meaningful context beyond the schema. The 'target' maxLength and default are schema-only, but the description clarifies its semantic scope.

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

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

The description clearly specifies the verb 'expliquer' (explain) and the resource 'la limite des actions locales' (local action boundary). It lists exact trigger conditions (install, download, update, run, delete, scan, benchmark) that distinguish it from sibling tools like 'check_pc_for_local_ai' and 'recommend_runtime'.

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

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

The description explicitly states when to call the tool: for any request to install, download, update, run, or delete Ollama, a model, or driver, as well as scanning or benchmarking. It also provides strong negative guidance: after the call, do not add commands, procedures, web searches, external sources, or manual alternatives. This covers both triggers and post-call constraints.

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

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

Annotations already declare readOnlyHint true. The description adds valuable behavioral context: it will not invent speeds if the report lacks proof, and it only operates on public reports. This goes beyond what annotations provide, giving the agent a clear honesty guarantee and scope constraint.

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

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

The description is two concise sentences, front-loaded with the core purpose. Every word adds value: the verb, resource, scope, honesty guarantee. No redundancy or fluff.

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

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

For a read-only tool with a single parameter, the description covers the essential: what is returned, the source constraint (public report), and behavior when no proofs exist. The presence of an output schema reduces the burden to explain return values. It could mention error states beyond 'no proof', but overall it is complete enough for an agent.

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

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

Despite 0% schema description coverage, the description compensates by specifying the expected URL format ('https://outilsia.fr/r/...') and that the report must be public. This adds meaningful semantic context beyond the schema's type/format constraints, helping the agent provide proper input.

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

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

The description clearly states the tool returns tokens/s already measured in a public report, specifying the URL format. It distinguishes from siblings like list_installed_models_from_report by focusing on benchmark proofs. However, it lacks explicit differentiation language, keeping it one step below perfect.

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

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

The description implies the tool should be used for reading existing measurements from public reports. It does not provide explicit guidance on when to use alternatives among the sibling tools, nor does it state when not to use this tool. The context is clear but leaves the agent to infer usage boundaries.

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

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

Annotations already declare readOnlyHint=true and destructiveHint=false, establishing safe read behavior. The description adds significant context: the tool returns only first-party, dated, non-extrapolated measurements from an unfinished multi-machine campaign. This goes beyond annotations to inform the agent about data scope and limitations.

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

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

The description is three sentences, each adding distinct information: return content, non-extrapolation, campaign state. It is front-loaded with the main purpose. Minor deduction for the cryptic third sentence ('Campagne multi-machines non terminée') which could be clearer.

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

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

The tool is simple with one optional parameter and an output schema exists (so return values need not be elaborated). The description adequately covers what is returned and key behavioral constraints. However, the missing explanation of the 'query' parameter creates a gap in completeness, as the agent has no guidance on how to use the sole input.

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

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

The input schema has one optional parameter 'query' with 0% description coverage, and the tool description does not explain its purpose or expected format. Given the low schema coverage, the description should compensate but fails to add any meaning to the parameter, leaving the agent to guess whether it filters results or something else.

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

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

The description clearly states that the tool returns dated public benchmarks (machine, runtime, tok/s, reference) from the OutilsIA first-party source. It adds specificity about non-extrapolation and campaign state, distinguishing it from sibling analysis tools. However, it does not explicitly differentiate from siblings in a comparative way.

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

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

No guidance is provided on when to use this tool versus alternatives. The constraints (not extrapolated, campaign not finished) imply boundary conditions but are not framed as usage instructions or compared to sibling tools like analyze_shared_report or check_pc_for_local_ai.

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, openWorldHint=false, destructiveHint=false, so the tool is clearly a safe read operation. The description adds meaningful context beyond annotations: it specifies the source is a public report at https://outilsia.fr/r/..., and reiterates it does not access the machine or install anything. This extra behavioral context is valuable, but a 5 would require even richer details like error behavior or access constraints.

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

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

The description is two concise sentences, both front-loaded with purpose and constraints. Every word earns its place, no redundancy. However, a 5 would require perfectly optimizing for reading order by leading with the most critical operational constraint first; here both sentences are equally important.

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 single parameter, excellent annotations (readOnlyHint, safety hints), and a presumably defined output schema (has output schema: true), the description is complete. It explains the tool's action, the source format (public report), and what it does not do (no machine access, no installation). There is no gap given the complexity.

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

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

Schema description coverage is 0%, so the description carries the full burden for the single parameter 'report_url'. The description mentions 'un rapport public https://outilsia.fr/r/...' which gives the parameter meaning – it's a URL to a specific report format. This adds value beyond the schema's format constraint. A 5 would require explicit param documentation (e.g., 'report_url: the full URL of the OutilsIA report'), but the description compensates adequately.

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

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

The description clearly states the tool reads (lit) installed models from a public report URL, contrasting with sibling tools that analyze, check, explain, or recommend. The verb 'Lit uniquement' (reads only) and the specific resource 'modèles installés déjà présents dans un rapport' precisely distinguish it from similar list tools like 'list_benchmark_proofs_from_report' or 'list_first_party_measurements'.

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

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

The description explicitly states when to use this tool: to read installed models already present in a public report. It also tells when not to use it by clarifying 'N'accède pas à la machine et n'installe rien' – it does not access the machine or install anything. This directly distinguishes it from sibling tools like 'check_pc_for_local_ai' or 'simulate_hardware_upgrade'.

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

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

Annotations already declare readOnlyHint=true and destructiveHint=false. The description adds valuable behavioral context: it is only a catalog estimate, not a real scan or benchmark, and does not fabricate tokens/s. This goes beyond the annotations and helps the agent understand the tool's limitations and data sources.

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

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

The description is two short sentences with no redundancy. The first sentence states the core function, and the second adds critical limitations. Every word earns its place; it is front-loaded and efficient.

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

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

Given the existence of an output schema and annotations, the description does not need to detail return values. However, it omits explanation of two parameters (unified_memory, storage_free_gb) and does not describe how filtering works internally (e.g., exact match, inclusive, ordering). The core idea is conveyed, but gaps remain for full contextual understanding.

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

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

Schema description coverage is 0%, so the description should compensate. It mentions vram_gb (required), ram_gb (optional), and usage, but ignores unified_memory and storage_free_gb. This leaves two parameters unexplained, which is a significant gap for a tool with five parameters.

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

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

The description clearly states a specific verb ('filtre') and resource ('catalogue public') along with key parameters (VRAM, RAM, usage). It also clarifies the tool's scope ('estimation catalogue uniquement'), which helps distinguish it from siblings that might perform real scans or benchmarks. However, it does not explicitly differentiate from specific sibling tools by name.

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

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

The description implies usage context: 'Estimation catalogue uniquement : pas un scan, pas un benchmark, pas de tokens/s inventés' tells the agent that this is for quick catalog-based filtering, not for live measurements. But it does not explicitly state when to prefer this tool over alternatives like 'check_pc_for_local_ai' or 'recommend_runtime', nor does it provide exclusion criteria.

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

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

The annotations already declare readOnlyHint=true, destructiveHint=false, and openWorldHint=false, establishing a safe, bounded read operation. The description adds one detail: it does not invent tokens/s (meaning no hallucination), which is a useful behavioral note beyond annotations. However, it omits other relevant behaviors such as whether it accesses a live API or local cache, rate limits, or result format. With annotations covering safety, 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?

The description is two sentences with zero wasted words. Every sentence adds necessary context: the first covers the core purpose and searchable dimensions, the second clarifies it's not a scan and doesn't generate fabricated data. This is exemplary conciseness.

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

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

The tool has one simple string parameter, high-coverage annotations, an output schema, and is part of a sibling group focused on hardware/report tools. The description adequately explains the search action and the public catalog scope. However, it doesn't describe what the output contains (though an output schema exists, reducing the burden), and it doesn't address data freshness or query constraints beyond maxLength. For a single-param lookup, this is minimally adequate but not thorough.

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

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

The input schema has a single parameter (query) with 0% schema description coverage, meaning the JSON schema provides no semantic hints beyond type and length constraints. The description partially compensates by listing search dimensions (name, size, or Ollama tag), which gives the agent guidance on what 'query' can contain. However, this is minimal—it doesn't explain formatting, case sensitivity, or how multiple dimensions combine. Baseline 3 is reasonable given the low coverage but some added value.

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

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

The description clearly states the verb 'Cherche' (search) and the resource 'dans le catalogue public OutilsIA' with specific search dimensions (name, size, or Ollama tag). It also explicitly distinguishes itself from siblings by stating 'Ce n'est pas un scan', which is unique among the sibling tool names that revolve around reports, benchmarks, and hardware analysis.

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

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

The description states what the tool does and that it searches a specific public catalog, providing basic context. However, it does not specify when to prefer this over a sibling tool (e.g., when checking for model availability vs. analyzing a runtime report), nor does it mention any conditions for non-use or alternatives. The 'no invention of tokens/s' is a negative clarification but not a usage directive.

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

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

Annotations already declare readOnlyHint=true and destructiveHint=false, so the description's main behavioral contribution is the negative clarification (not a scan/benchmark). The description does not disclose any additional behavioral traits such as expected output format, error handling, or whether the tool requires internet access. With annotations covering the safety profile, the description adds only marginal 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?

The description is two sentences, no filler, front-loaded with the purpose. Every sentence adds value. It is appropriately sized for the tool's complexity.

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

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

Given the tool has 5 parameters, an output schema, and multiple siblings, the description is brief but covers the core purpose. However, it fails to explain the 'usage' and 'unified_memory' parameters, offers no examples, and does not clarify how the tool relates to siblings. It is adequate but has clear gaps.

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

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

Schema description coverage is 0% for 5 parameters, so the description must compensate. It mentions three of the five parameters (OS, VRAM, RAM) but omits 'usage' and 'unified_memory', and does not explain the enum values for 'usage'. The description adds some meaning beyond the schema, but incomplete coverage leaves the agent guessing about the missing parameters.

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

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

The description clearly states the action ('chooses a runtime path') and the key inputs (OS, VRAM, RAM), and it explicitly excludes other actions (installation, scan, benchmark). The title specifies the runtimes (Ollama, LM Studio, llama.cpp). However, it does not differentiate from sibling tools like check_pc_for_local_ai or list_models_for_budget, leaving some ambiguity about when to use this tool over those.

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 provides negative guidance: what the tool is NOT (installation, scan, benchmark). It offers no positive guidance on when to use this tool vs. alternatives, no prerequisites, and no context about the recommended use case. This is insufficient for an agent to decide when to invoke this tool.

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

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

Annotations already declare readOnlyHint=true, destructiveHint=false, and openWorldHint=false. The description adds that no recalculation occurs ('sans recalculer'), which aligns with read-only behavior. However, it does not disclose error handling, validation, or any other behavioral details 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?

The description is a single short sentence with no filler. It is efficient but may be too terse for non-French-speaking agents. Every word earns its place, but the structure is minimal.

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

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

Given the tool has one deeply nested input parameter and no output schema shown here, the description fails to explain the rendering behavior, output format, or what happens with invalid decision objects. The agent lacks guidance on prerequisites and edge cases.

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

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

Schema description coverage is 0%, so the description bears full responsibility for parameter meaning. It states the decision is 'produite par un outil OutilsIA de cette app', which hints at origin but lacks specificity about which sibling tools generate valid decisions. The complex nested schema is left entirely to the agent to infer.

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

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

The description clearly states the verb 'Affiche' (display) and the resource 'une décision produite par un outil OutilsIA de cette app'. It distinguishes the tool by specifying 'sans recalculer' (without recalculating), which sets it apart from potential sibling tools that might recompute decisions.

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

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

The description implies usage when you want to view a decision without recomputation, but it provides no explicit when-not-to-use guidance or alternatives. Sibling tools like 'check_pc_for_local_ai' or 'simulate_hardware_upgrade' likely produce the decision, but this is not stated.

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

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

The description clearly states that the simulation is non-destructive ('ne modifie rien') and even reveals a potential outcome conclusion pattern, which goes well beyond the readOnlyHint annotation which only indicates it's read-only. No contradictions with annotations.

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

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

The description is two sentences with no wasted words. It front-loads the purpose and follows with critical behavioral and usage guidelines. 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?

Given the output schema exists and context signals show 4 parameters with one required, the description is complete. It explains what the tool does, how it works (non-destructive), and when to avoid using it. No gaps remain.

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

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

Schema description coverage is 0%, so the description must compensate. While the description doesn't detail each parameter, it references the core concepts of 'RAM ou VRAM' which map to 'target_ram_gb' and 'target_vram_gb', and 'profil' which maps to 'profile'. It also mentions 'usage' implicitly via context of comparing profiles. It adds functional meaning but could be more explicit about parameter roles.

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

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

The description uses a specific verb ('Compare') and resource ('profil avant et après une hausse de RAM ou VRAM'), making it clear what the tool does. It also helps distinguish this tool from siblings like 'check_pc_for_local_ai' by stating its comparative nature.

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

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

The description explicitly states when not to use this tool ('ne modifie rien') and includes a conditional guideline ('doit conclure qu'aucun achat n'est utile si le catalogue ne montre pas de gain'), which helps the agent decide to call it only when confident a gain might exist.

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