BRANCO - Droit français

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

The annotations already declare readOnlyHint=true, idempotentHint=true, and openWorldHint=false, so the safety profile is fully covered by structured data. The description adds nothing beyond that – not what a tool description returns, not how a missing tool is handled, not the set of valid operations. With no output schema, the absence of return-shape context is a real 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 sentences with no padding, and the action is front-loaded. But the brevity comes at the cost of under-specification rather than economy.

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 introspection tool with no output schema and 0% schema coverage, the description should at minimum enumerate the operations and explain what is returned. Neither is present, leaving an agent unable to build a valid or interpretable call.

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% across both parameters, so the description carries the full burden and does not meet it: 'nom' is never mentioned, and 'operation' is described only by the tautology 'choisit une opération' with no enumerated or example values. An agent would have to guess what to pass.

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?

It names a specific verb and resource – 'Décrit un outil' – which is enough to set it apart from the explorer_* siblings, all of which are read-only domain explorers rather than a registry-lookup tool. The qualifier 'accessible' is vague about scope, but the core action is unmistakable.

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?

'operation choisit une opération' is circular and gives no indication of which operations exist or when to call this instead of an explorer_* tool. The description states no prerequisites, no exclusions, and no alternatives.

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

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

Annotations already establish the safe-read profile (readOnly, idempotent, non-destructive), so the bar is lower. The description adds genuinely non-obvious behavior: each operation must preserve dates, documents, and hypotheses as traceability context, and each requires a prior contract lookup via decrire_outil. It does not describe what the computation returns, but adds meaningful process context beyond 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?

The traceability instruction is front-loaded and useful, but the decrire_outil guidance is stated twice in near-identical sentences, wasting space that could have explained 'arguments'. Short overall, but redundancy costs it.

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?

Deferring to decrire_outil is a coherent design for a twelve-operation dispatcher, and no output schema exists so return values need no explanation. However, for a tool with an opaque required 'arguments' object, the description leaves the agent without enough to construct a call and relies entirely on a separate tool call.

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% with two parameters. The description mentions only the operation name; the nested 'arguments' object (additionalProperties: true, shape unknown) is never explained, and an agent gets no guidance on how to populate it or whether it is operation-specific. This is the largest gap given the free-form nested object.

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 first clause names concrete subject matter — legal calculations, statistical series, and compensation — which distinguishes it from the sibling explorer_* tools that fetch doctrine, case law, or sources. It does not enumerate the twelve operations, but the enum in the schema carries that detail. Purpose is clear at the 'calculation engine' level without sibling differentiation being explicit.

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 an explicit workflow: pick an operation, then call decrire_outil with that operation's name to get its exact contract before invoking. That is real when-to-use guidance. It does not, however, say when to prefer this over the other explorer_* tools, and the guidance is repeated twice rather than expanded.

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 establish that this is a read-only, idempotent, non-destructive, closed-world tool. The description adds useful behavioral context beyond that by stating that it returns provenance and status for each publication and that the exact operation contract must be obtained through decrire_outil before use.

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 purpose is front-loaded and the language is not bloated, but the final two sentences repeat the same instruction to call decrire_outil before use. Removing that duplication would make the definition tighter without losing information.

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

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

For a tool with seven operations, a nested arguments object, and no output schema, the description is only minimally complete. It appropriately tells the agent to obtain the exact contract from decrire_outil, but it does not explain the operations themselves or help compare this tool with sibling explorers.

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 does not explain the meaning of the seven operation enum values or what the nested arguments object should contain. It only says to choose an operation and consult decrire_outil, leaving most parameter semantics to be discovered elsewhere.

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 read-oriented resource: archived doctrinal and institutional collections, including each publication's provenance and status. It is clearly not a generic search tool, but it does not explicitly distinguish itself from sibling explorers such as explorer_doctrine_ouverte.

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

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

It gives a required procedural guideline: choose an operation and call decrire_outil with that operation name before use. However, it provides no guidance on when to choose this archived-doctrine explorer versus the many sibling explorer tools, 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 readOnlyHint/true, idempotentHint/true, destructiveHint/false and openWorldHint/true, so the safety profile is covered. The description adds one genuinely behavioral detail beyond that: a mandatory prerequisite step (call decrire_outil with the chosen operation name to obtain its contract before use). It says nothing about the fact that results are federated across heterogeneous external sources, about latency, or about rate limits.

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 purpose is front-loaded, but the last two sentences say the same thing twice: "appeler decrire_outil avec son nom avant usage" and "Appeler decrire_outil avec nom = opération choisie pour obtenir son contrat exact avant usage." That redundancy costs a third of the description's length for zero added 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?

There is no output schema, but the tool delegates per-operation contracts to decrire_outil, which is a legitimate completeness strategy for a dispatcher. What remains missing is disambiguation against explorer_doctrine_archivee and any hint about the shape of the 'arguments' payload.

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 carry the burden. The ten enum values are self-describing for 'operation', and the instruction to resolve the contract via decrire_outil is a real mitigation, but the 'arguments' envelope — a free-form nested object with additionalProperties:true — is left entirely unexplained (what keys, keyed by operation, optional vs 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?

The description names the resource domain ("Doctrine et thèses ouvertes") and hints at intent ("identifier le fonds, l'auteur et la publication"), but gives no verb — it is a noun phrase, not a statement of what the tool does. It also fails to distinguish itself from the sibling explorer_doctrine_archivee, leaving the agent to guess what "ouverte" excludes.

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?

"Choisir une opération puis appeler decrire_outil" is invocation mechanics, not usage guidance — it says how to call, not when to call this instead of explorer_doctrine_archivee or explorer_fonds_et_couverture. No conditions, no exclusions, and nothing about which of the ten operations suits which research question (theses juridiques vs HAL vs DOAJ vs Persée).

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, non-destructive, closed-world, so the safety profile is covered. The description adds a non-obvious behavioral contract: the tool is a dispatcher whose per-operation argument shape must be fetched via decrire_outil before use, plus an instruction to preserve the procedure phase and references in results — real context beyond 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?

The resource framing is front-loaded and the text is short, but the decrire_outil instruction is stated twice in near-identical wording, wasting one of only three sentences. The clause about preserving procedure phase and references is vague and unanchored to any concrete behavior.

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 23-operation dispatcher with no output schema and zero schema coverage, the description is thin — it never groups the operations into families (thematic files, cassation, appel, orientations, circulaires, parcours) that would let an agent pick correctly. The decrire_outil escape hatch mitigates this but pushes all real discovery into 23 follow-up calls.

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 'arguments' is an undocumented free-form object, so the description bears the burden. It partially compensates by routing the agent to decrire_outil for the exact per-operation contract, but it never explains that 'arguments' varies per operation nor gives any example, leaving the second required parameter opaque.

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

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

The description names the resource domain (criminal case files, pathways, decisions, orientations) but uses a bare noun phrase with no verb, and gives no cue to distinguish it from close siblings such as explorer_procedure_penale or explorer_qualification_et_peines. The 23-operation enum in the schema does more to reveal the actual scope than the description does.

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

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

It gives one explicit procedural rule — pick an operation, then call decrire_outil with that name to get the exact contract before invoking. That is genuinely useful workflow guidance, but there is no guidance on when this explorer should be chosen over its many sibling explorers, nor which operation class fits a given question.

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, non-destructive and openWorld, so the safety profile is covered. The description adds genuinely useful behavioral context: a mandatory contract-discovery step via decrire_outil before invocation, and the warning that territories and institutions must be distinguished. It still says nothing about response shape or what a dispatch failure looks like.

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

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

The final two sentences are near-duplicates, both stating that decrire_outil must be called with the chosen operation name before use — pure redundancy. The domain scoping is front-loaded well, but the repetition wastes roughly a third of 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 dispatcher with an 11-value enum, an undocumented nested arguments object and no output schema, the description does cover the critical prerequisite (fetch the contract first) and the domain boundaries. It remains incomplete on how to populate 'arguments' and on what results look like, which matters because each operation likely has a different contract.

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

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

Schema description coverage is 0%. The enum value names are self-explanatory for 'operation', and the description gestures at passing the chosen operation name (calling it 'nom' rather than the actual field name 'operation'). But the required free-form 'arguments' object — additionalProperties true, nested — is never explained at all, leaving the agent to guess its shape per operation.

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

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

The description names a domain (Senegalese/West African law, OHADA, UEMOA) and instructs distinguishing territories and institutions, which does separate it from siblings like explorer_droit_europeen or explorer_sources_francaises. However, it never states what the tool actually does — it is implicitly a dispatcher over an 'operation' enum, and that verb+resource framing is never spelled out.

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

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

It gives an explicit workflow: pick an operation, then call decrire_outil with that operation name to obtain the exact contract before use. That is concrete 'how/when' guidance, and it names the sibling decrire_outil directly. It stops short of saying when to prefer this domain router over another explorer_* router.

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's added value is the mandatory two-phase call pattern via decrire_outil, which is real behavioral disclosure beyond the annotations. It says nothing, though, about what a call returns, whether results are paginated, or how the free-form 'arguments' bag behaves — a notable omission for a dispatcher tool with a wildcard object parameter.

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?

Short and front-loaded with purpose, but the second and third sentences are near-verbatim duplicates ('appeler decrire_outil ... avant usage' repeated twice), so one sentence is pure waste. The phrasing 'obtenir son contrat exact' is also ambiguous (likely a literal rendering of 'contract/schema') and the 'nom' vs 'operation' naming mismatch adds noise rather than signalling.

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 thin dispatcher whose real contract lives behind decrire_outil, deferring detail is defensible, and no output schema exists to explain. Still, given 0% parameter coverage and a free-form nested 'arguments' object, an agent finishing this description knows the domain and the pre-step but not what either operation does or what arguments to expect — it must make an extra round-trip before it can even judge relevance against 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 0%, so the description must carry the burden and it largely does not. It gestures at 'operation' by saying to choose one ('rechercher' / 'lire' loosely map to the enum values), but it never mentions the required 'arguments' object at all — a nested free-form bag with additionalProperties:true that is the hardest part of the contract. Worse, it tells the agent to pass 'nom = opération choisie', while the actual schema field is called 'operation', which can actively mislead.

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 pair and resource: 'Recherche et lecture du droit de l'Union européenne', which distinguishes the legal domain from siblings like explorer_droit_africain or explorer_droit_international. It is clear what the tool covers, but it never names the sibling tools or explains the boundary (e.g. EU vs. international law overlap), so the differentiation is left implicit in the domain word 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?

Gives one explicit procedural rule: pick an operation, then call decrire_outil with its name before use. That is genuine workflow guidance an agent could not infer. However, there is no guidance on when to pick this explorer over the thirteen sibling explorers, and no hint about which of the two operations (rechercher vs. lire) to choose for a given need.

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, open-world and non-destructive, so the safety profile is covered. The description adds one valuable trait beyond them - that operations are self-describing only on demand and should be inspected via decrire_outil first - but discloses nothing about scope, result shape or limits of any operation.

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?

It is short, but the second and third sentences say essentially the same thing ('call decrire_outil with its name before use' vs 'call decrire_outil with nom = chosen operation'), wasting a third of the text on a repeat. The domain framing leads, which is good, but the message is not tightened.

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 dispatcher with a large opaque enum, a free-form arguments bag and no output schema, the description does at least point the agent to the mechanism (decrire_outil) that fills the gap. It still omits any orientation about which operation suits which need, and nothing tells the agent what a successful call looks like.

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 two required parameters, so the description must compensate and it largely does not: none of the seven operations in the enum are named or explained, and the `arguments` object (nested, additionalProperties: true) is not described at all. The only semantic offering is the instruction to look up contracts via decrire_outil, which offloads rather than explains.

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

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

The description names the domain (international jurisprudence, UN treaty-body committees) and hints that the tool routes among jurisdictions, treaties and legal orders, but never states plainly that it is a dispatcher over seven named operations or what a call actually returns. The verb is only implicit, so an agent must infer the tool's function from the name and the enum.

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

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

It gives a usable workflow (pick an operation, then call decrire_outil with that operation name to get its contract before use), which is genuine 'when/how' guidance. It says nothing, however, about when this tool is the right choice versus siblings such as explorer_droit_europeen or explorer_jurisprudence, so sibling selection is left to the agent.

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

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

Annotations already declare readOnly, idempotent, non-destructive and closed-world, so safety needs no restating. The description's real contribution is the mandatory two-step discovery protocol (decrire_outil before use), which is behavior an agent could not infer from the schema. It says nothing about what each operation returns, whether results are exhaustive, or how the arguments object must be shaped for a given operation.

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?

Short overall and the purpose sentence is front-loaded. But the second and third sentences say essentially the same thing (call decrire_outil with the chosen operation name before use), so one of three sentences is pure redundancy.

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

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

This is a 13-way dispatcher with no output schema, no parameter documentation, and a free-form arguments bag. The description leaves the agent unable to choose an operation without first round-tripping through decrire_outil for each candidate, and gives no hint about what any of the fonds/couverture operations cover.

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 explains neither the 'operation' selector (13 enum values, undocumented) nor the free-form 'arguments' object. It only redirects the agent elsewhere (decrire_outil) rather than compensating, and it never notes that arguments must match the chosen operation's contract — a significant gap given additionalProperties:true on a nested object.

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 topic area ('état des fonds, couverture documentaire, actualisation des sources') but uses no verb and no explicit resource framing, so it reads as a subject label rather than an action. The operation enum supplies the real granularity, but nothing in the prose tells an agent what calling this tool actually produces. It is distinguishable from data-oriented siblings (jurisprudence, procedure_penale), but not sharply from explorer_sources_francaises or explorer_sources_officielles.

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 an in-tool workflow — pick an operation, then call decrire_outil with that operation name to get its exact contract — which is genuine procedural guidance. However, it never states when to choose this tool over the 13 sibling explorers, nor which of the 13 operations fits which question. Usage is implied rather than routed.

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 (readOnly, idempotent, non-destructive, closed-world), so the bar is lower, and the description adds a genuinely non-obvious behavioral rule: this is a dispatch facade whose per-operation contract must be fetched via decrire_outil first. That is exactly the kind of context annotations cannot express. It still omits whether operations are pure reads at the sub-level and how failures are surfaced.

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 domain sentence is front-loaded and compact, but the final two sentences say the same thing twice ('appeler decrire_outil ... avant usage' / 'Appeler decrire_outil avec nom = opération choisie ... avant usage'). Roughly a third of the text is redundant repetition rather than added information.

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

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

For a 12-operation dispatcher with a free-form arguments bag, no output schema, and zero parameter documentation, the description does address the single biggest risk by mandating contract discovery via decrire_outil. It still leaves the operation catalogue unexplained and gives no sense of what a result looks like or how the 12 operations partition the domain.

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

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

Schema coverage is 0%: the `operation` enum lists 12 opaque French operation names with no descriptions, and `arguments` is a free-form object with additionalProperties and no documented shape. The description compensates partially by directing the agent to decrire_outil for the exact contract of the chosen operation, but it never explains what `arguments` should contain or that it varies per operation.

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

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

The description names the topical domain (French case law, rapporteur public conclusions, relations between decisions) but never states what the tool mechanically does — it is a router over 12 operations, and no verb or resource framing conveys that. It gestures at differentiation ('distinguer chaque juridiction et formation') without naming any sibling explorer it is distinct from. An agent knows the subject area but not the action.

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 two-step protocol is explicit and repeated: pick an operation, then call decrire_outil with that operation name to get its exact contract before use. That is real, actionable guidance. However, nothing says when to reach for this explorer versus explorer_procedure_penale, explorer_qualification_et_peines, or the other domain siblings, nor how to choose among the 12 listed operations.

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=false, so the safety profile is covered. The description adds a genuine behavioral prerequisite (mandatory decrire_outil introspection before use) but says nothing about error behavior for unknown operations, how 'arguments' are validated, or what the dispatch returns — and it names a non-existent operation, which undermines trust in the described flow.

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?

Reasonably short, but the instruction to call decrire_outil before use is stated three times in slightly different words ('avant usage' twice plus the final sentence), which is wasted space in an already under-specified 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?

This is a dispatcher over seven undocumented operations with an untyped nested arguments bag and no output schema. For that complexity, the description should enumerate what each operation does and what arguments each expects; instead it names only two operations and one of them does not exist, leaving the agent unable to select or populate a call without a second introspection round-trip.

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%: the seven-value 'operation' enum has no per-value documentation anywhere, and the nested 'arguments' object is completely unexplained (no indication of which keys each operation expects). The description compensates only minimally by naming two operations, one of which ('lire_source') is not in the enum, so it does not fill the coverage gap it needs to.

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 lists three loosely related domains (citation checking, authority hierarchy, act templates) but never states that this is a dispatch/facade tool routing to sub-operations, nor does it explain how those domains map to the seven enum values. It is distinguishable from siblings by topic area, but the agent must infer the tool's actual shape from 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?

It gives a concrete sequencing rule ('choisir une opération puis appeler decrire_outil avec son nom avant usage', and a chained flow for the two-operation case), which is real guidance. However, it offers no when-not-use or sibling comparison (e.g., versus explorer_jurisprudence or explorer_sources_francaises), and the recommended chain references 'lire_source', which is not among the enum operations.

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=true, idempotent=true, and destructive=false, so the safety profile is covered. The description adds the requirement to preserve qualification, dates, and procedural phase, and to fetch the exact contract via decrire_outil before use, but it does not explain what each operation returns or how arguments are handled.

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 purpose is front-loaded, but the second and third sentences repeat the same decrire_outil prerequisite almost verbatim. The repetition wastes space without adding information.

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

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

For a tool with eight operations, a nested free-form arguments object, zero schema descriptions, and no output schema, the description is thin. Delegating to decrire_outil is a reasonable mitigation, but the description still leaves the agent without enough domain or parameter detail to know what is being audited or calculated.

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, but it only says to call decrire_outil for the exact contract and vaguely references qualification, dates, and phase. It does not explain the structure of the arguments object or what each of the eight operation enum values expects.

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

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

The description states the domain (criminal procedure and sentence execution) and implies checks/audits, but never names a concrete verb or explains what the eight operations actually do. It is distinguishable from broad siblings like explorer_jurisprudence only by domain, not by action.

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

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

It tells the agent to pick an operation and call decrire_outil first, which is a workflow prerequisite, not guidance on when to use this tool versus explorer_qualification_et_peines or explorer_dossiers_penaux. No when-to-use, when-not-to-use, or alternative routing is provided.

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

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

Annotations already declare readOnlyHint, idempotentHint, destructiveHint=false and openWorldHint, so the safety profile is covered without help from the text. The description adds two pieces of non-annotated behavior: the requirement to preserve the facts and reference date, and the mandatory decrire_outil introspection step before invocation. It says nothing about NATINF lookup coverage or result shape, so it is useful but not rich.

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

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

The text is short and front-loads the domain, but the final two sentences say the same thing twice — choose an operation and call decrire_outil with its name — so roughly a third of the description is redundant repetition that should be collapsed into one instruction.

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

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

With no output schema, 0% parameter documentation, and a nested free-form arguments object gating four distinct operations, the description carries a heavy burden and discharges it by pointing at another tool. An agent still cannot tell what each operation consumes or produces without an extra round trip, which is a significant completeness gap for a multi-operation dispatcher.

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 parameters are non-trivial: an 'operation' enum of four values plus a free-form nested 'arguments' object with additionalProperties=true. The description never enumerates the operations or explains what arguments each expects, instead deferring entirely to decrire_outil, leaving the agent unable to construct a valid arguments payload from the definition alone.

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 is a noun-phrase list of subject matter ('Qualification pénale, nomenclature NATINF et peines encourues ou observées') rather than a verb+resource statement, so the agent must infer from the tool name that this is a read/exploration dispatcher. It is clear about the legal domain but does not say what the tool actually returns or does with those topics, and it does not distinguish itself from siblings like explorer_procedure_penale or explorer_methodes_et_actes.

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

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

It gives a workflow rule — pick an operation, then call decrire_outil with that operation name to get its exact contract — which is genuine routing guidance. However, it gives no when-to-use vs. when-not guidance relative to the many sibling explorers, and no preconditions such as needing facts and a reference date before qualifying an offence.

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 the non-obvious dispatch behavior — that the tool is a two-step façade requiring a decrire_outil lookup before a valid call — which is real behavioral context an agent would otherwise not know. It still omits error behavior for an invalid operation name and any indication of what results look like.

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

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

The opening clause is dense and front-loaded, but the final two sentences are near-verbatim duplicates ('appeler decrire_outil avec son nom' / 'appeler decrire_outil avec nom = opération choisie'), wasting roughly a third of the text on a single repeated instruction.

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 32-operation open-world dispatcher with an opaque nested `arguments` object and no output schema, the description does the minimum: it routes the agent to decrire_outil for the real contract. It does not convey the breadth of covered domains, how results are shaped, or how to choose among 32 operations, leaving meaningful gaps for a tool of this complexity.

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

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

Schema coverage is 0%: the 32-value operation enum has no per-value documentation and `arguments` is an unconstrained additionalProperties object. The description compensates meta-semantically by telling the agent that the exact argument contract must be fetched via decrire_outil with the chosen operation name, but it does not itself explain what any operation expects, so a correct call requires a second tool call.

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 domain (French legal sources, their versions and relations, plus qualification and applicable-law checks) and a verb (search/consult), which separates it loosely from explorer_sources_officielles and explorer_droit_europeen. But the tool is actually a 32-operation multiplexer whose enum spans Judilibre exports, Défenseur des droits decisions, Kali conventions and international-crimes case law — none of which the description hints at, so the stated purpose under-represents the actual scope.

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

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

It gives a concrete invocation procedure: pick an operation, then call decrire_outil with that operation name to obtain the exact contract before use. That is genuinely actionable. However, it says nothing about when to prefer this explorer over its many siblings (explorer_sources_officielles, explorer_jurisprudence, explorer_fonds_et_couverture) or when an operation belongs to a different explorer.

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, non-destructive, closed-world behavior, so the safety profile is covered structurally. The description adds that each document carries version and provenance information, which is useful output context, but says nothing about result volume, pagination, or what a failed operation lookup returns.

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

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

The resource inventory is front-loaded, which is good, but the two closing sentences say essentially the same thing twice ('call decrire_outil with its name before use' / 'call decrire_outil with name = chosen operation to get its exact contract before use'). That duplication is pure waste in an otherwise short 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?

For a dispatcher with 15 operations, a free-form nested arguments object and no output schema, the mandatory decrire_outil step is the right structural answer to the missing contract detail. What remains missing is any mapping between this tool's scope and the neighbouring doctrine/sources explorers, which is the main ambiguity an agent faces when choosing among them.

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

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

Schema coverage is 0% and the `arguments` object is a free-form bag whose contents vary per operation, which would normally be a severe gap. The description partially compensates by instructing the agent to call decrire_outil for the exact contract of the chosen operation, giving a concrete discovery path. Still, nothing here describes what the arguments contain or how the operation enum maps to argument shapes.

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

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

The description names the resource domain well (official documents, tax doctrine, circulars, agreements, opinions, plus version/provenance metadata), which tells an agent what corpus this covers. But it never explains that this is a 15-operation dispatcher, nor does it distinguish it from siblings like explorer_doctrine_archivee, explorer_doctrine_ouverte or explorer_sources_francaises, which overlap on the same doctrine material.

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

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

It gives an explicit, mandatory workflow: pick an operation, then call decrire_outil with that operation name to obtain the exact contract before invoking. That is clear procedural context an agent would otherwise have to guess. It stops short of saying when to prefer this tool over the overlapping explorer_* siblings, so no exclusions or alternatives are stated.

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