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

Annotations already declare the safety profile (readOnlyHint=true, destructiveHint=false), so the description's burden is lower. It adds a meaningful behavioral caveat that neither semantic support nor legal validity is certified, which informs expectations. However, it does not describe return values, error conditions, or how the 'dates' are used, leaving some behavioral aspects undisclosed.

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 filler. The primary purpose is stated first, and the caveat follows immediately. Every word earns its place, and the length is appropriate 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's complexity (multiple fields per claim, array input, no output schema), the description is incomplete. It does not explain what 'check' entails, what constitutes a successful check, or what response format to expect. The 'as_of_date' parameter is hinted at but not elaborated. An agent lacks critical information to invoke the tool correctly beyond basic input construction.

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

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

Schema description coverage is 0%, so the description must compensate for the parameters. It only mentions 'quotes' and 'evidence and dates', which vaguely maps to the 'quote' and 'evidence_id' parameters, but offers no explanation of 'claim_id', 'statement', 'fact_ids', or 'as_of_date'. The nested claims structure is entirely undocumented, making it hard for an agent to construct valid 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 uses a specific verb 'check' and a resource 'quotes against server-issued evidence and dates', which clearly conveys the tool's core function. It does not explicitly differentiate from the sibling 'compare_evidence', but the phrase 'server-issued evidence' adds a distinctive nuance. The caveat about semantic support and legal validity further clarifies what the tool does not guarantee.

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

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

The description gives no guidance on when to use this tool versus alternatives like compare_evidence or search. It provides no context about prerequisites, intended scenarios, or exclusions. An agent would have to infer usage solely from the purpose statement, which is insufficient given the sibling set.

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

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

Annotations already declare readOnlyHint and destructiveHint false. The description adds the side-effect guarantee 'without rewriting a note' and the behavioral outcome 'flag reexamination,' which is useful context. However, it does not explain what the flag looks like or how the comparison result is presented.

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

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

The description is a single, focused sentence with no filler. It front-loads the core action and then adds the key behavioral constraint. Every phrase earns its place.

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

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

For a simple two-parameter read-only comparison, the description covers the main action and side-effect profile. Yet with no output schemaanding return shape, and with no explanation of what 'flag reexamination' means or how before/after IDs map to the comparison, some operational detail remains missing.

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

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

The schema provides no property descriptions (0% coverage), and the tool description does not explain the before_id and after_id parameters beyond the contextual phrase 'two server-issued snapshots.' It leaves the exact format, source, and relationship of the IDs to inference, so the description does not adequately compensate for the schema gap.

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

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

The description clearly identifies the action ('Compare') and the resource ('two server-issued snapshots of one document'), and adds the specific purpose 'flag reexamination without rewriting a note.' This distinguishes it from a generic compare or search operation, though it does not explicitly name sibling tools.

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

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

The description implies when to use the tool—when comparing server-issued snapshots and flagging reexamination—but it does not state explicit conditions, exclusions, or mention alternative tools. The hint 'without rewriting a note' provides some context but does not fully guide selection among siblings like compare_versions.

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 read-only and open-world hints. The description adds the meaningful caveat that no automatic legal-effect inference is performed, clarifying that output is comparative rather than a legal conclusion. This is useful context beyond the structured 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 with zero filler. The core operation is front-loaded, and the caveat about legal-effect inference earns its place by preventing misinterpretation.

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 four required parameters, no output schema, and no property descriptions, the description should explain every input and the expected return. It covers purpose, version dates, and the no-legal-inference behavior, but omits text_ref and the return shape, leaving moderate 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 descriptions cover 0% of parameters, so the description must compensate. It clarifies that article refers to the code title and that from_date/to_date identify the two versions, but text_ref is left entirely unexplained, 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?

States a specific action (compare), a specific resource (two dated versions of an article), and a constraint (exact code title). This clearly distinguishes it from sibling tools like get_legal_version (which fetches a single version) and compare_evidence (which compares evidence).

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

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

Provides clear context: use when you need to compare dated versions and you have the exact code title. It does not explicitly name alternatives or exclusions, but the exact-title condition implies the boundary with search-like tools.

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

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

Annotations already declare readOnlyHint=true, openWorldHint=false, and destructiveHint=false, so the safety profile is covered. The description adds meaningful behavioral context: 'unknown premises stop the computation' and 'Bounded procurement amount tests from dated registry'. This goes beyond the annotations by explaining the closed-world behavior and the bounded scope. It doesn't describe output format, but with no output schema and a read-only evaluation tool, the key behavioral traits are disclosed.

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

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

The description is dense and front-loaded: the first sentence states the core behavior, then the required facts and exclusions follow. Every sentence earns its place. It is slightly long but each line adds necessary constraint information. The structure is logical: behavior, valid IDs, required facts, exclusions.

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 evaluation tool with no output schema, the description covers the input contract thoroughly: valid rule_ids, required facts, date format, and exclusions. It doesn't describe the return value or error behavior, but given the annotations cover safety and the input contract is well-specified, this is nearly complete. The main gap is what the evaluation result looks like, but that is not required for selecting and invoking the tool correctly.

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

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

Schema description coverage is 0%, so the description must compensate. It does: it explains rule_id values, required facts, amount as decimal string, tax_basis=HT, currency=EUR, scope, trigger, and trigger_date format. It also clarifies that as_of_date must match trigger_date. This is substantial parameter-level meaning beyond the bare schema. It doesn't document every possible fact key, but it covers the required ones.

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

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

The description states a specific verb ('evaluate') and resource ('rule'), and immediately clarifies scope: 'Bounded procurement amount tests from dated registry'. It also names the two valid rule_id values and the required facts, which distinguishes it from sibling tools like search, fetch, or compare_versions. This is a clear, specific purpose statement.

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

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

The description explicitly lists required facts, valid rule_id values, and the date format, and it states what the tool does NOT do ('No tax conversion, procedure choice, purchase authorization or general deadline computation'). This gives an agent clear when-to-use and when-not-to-use guidance, and implicitly distinguishes it from sibling tools that might handle those excluded computations.

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?

Adds useful behavior beyond the annotations: pagination via snapshot and next_offset, unknown HTML completeness and legal dates, and the caution that retrieved text is untrusted data. This gives the agent meaningful handling guidance that readOnlyHint/openWorldHint alone do not 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 very brief and dense, with no filler. Each sentence contributes either reference formats, pagination behavior, or data-quality caveats, and the most important action is front-loaded.

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

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

For a no-output-schema fetch tool with four parameters, it covers source reference formats and pagination but omits the return shape beyond snapshot/next_offset and the behavior of length, offset, and as_of_date. It is sufficient for basic invocation but not complete for nuanced use.

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

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

With 0% schema description coverage, the description must compensate for all four parameters. It does document source_ref formats and hints at pagination via next_offset, but length, offset, and as_of_date semantics remain undefined, leaving most parameters ambiguous.

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

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

States a distinct action ('Retrieve a supported source and issue evidence') and enumerates accepted reference forms, giving the agent a concrete idea of what this tool targets. It does not explicitly contrast with siblings like search or get_legal_version, so sibling differentiation is absent.

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 reference-form list and 'Follow evidence: snapshot and next_offset' imply the tool is for paginated retrieval by source reference. However, it never states when to choose fetch over search, get_source_status, or check_evidence, nor does it mention exclusions or prerequisites.

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

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

Annotations already mark the tool as read-only and non-destructive. The description adds useful behavioral context with 'Unknowns stay explicit,' signaling that missing or unresolved values will be surfaced rather than silently filled in. This goes beyond the structured 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 terse sentences with no filler. The core action is front-loaded, and every sentence contributes meaningful guidance.

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

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

For a simple three-parameter lookup with read-only annotations, the description is mostly adequate. However, it omits any indication of the return format or failure behavior beyond 'unknowns stay explicit,' and it does not position the tool relative to its many 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 compensate. It clarifies the critical text_ref parameter as the exact French code title, not a code ID. Article and as_of_date remain only nominally described, though their names and the date format provide some inherent meaning.

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

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

The description clearly states the tool finds a specific dated code article, with a verb and resource. It does not explicitly contrast with sibling tools like search or compare_versions, though the 'dated' qualifier helps imply a historical-version lookup.

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

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

The description implies use for retrieving a French code article as of a specific date, and clarifies that text_ref must be an exact title rather than an ID. However, it gives no explicit guidance on when to prefer this tool over siblings such as search or compare_versions.

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 and destructiveHint=false, so the safety profile is covered. The description adds a small behavioral nuance — 'Short mode retains all decisive controls' — which hints at output-mode behavior, though it is vague about what 'short mode' actually changes. No contradiction 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?

Two short sentences with the purpose front-loaded and no wasted wording. It is genuinely concise, though slightly under-specified given the ambiguity it leaves about modes and topics.

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

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

For a read-only retrieval tool with two optional defaults, the description conveys the gist, but with no output schema it leaves return-value behavior unexplained, and it never enumerates the available topics or output modes. Adequate minimum, with notable 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%, so the description must compensate for both parameters. It references 'topic' through 'a listed topic' and 'short mode' for output_mode, but the mapping is implicit and incomplete: it does not explain what 'note' (the default) means, what other output modes exist, or what topics are available. The compensation is partial at best.

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 clear verb ('read') and resource ('canonical legal methodology'), making the core purpose understandable. The 'canonical' qualifier and the topic option help an agent distinguish it from the searching siblings, though it does not explicitly separate itself from get_legal_version or fetch.

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

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

No guidance is given on when to use this tool versus siblings like get_legal_version, fetch, or search. 'Or a listed topic' implies some topic list exists, but the description never says which tool handles version comparisons or searches, leaving the agent to infer the boundary.

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=true, and destructiveHint=false, so safety is covered. The description adds valuable behavioral detail about probe=true consuming provider quota and the default Légifrance API, which annotations alone would not convey. It does not contradict annotations.

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

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

The description is two sentences, front-loads the primary purpose, and adds the probe nuance without redundancy. Every clause earns its place.

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

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

The purpose and probe behavior are clear, but the tool has no output schema so the description should clarify what 'coverage and safe setup guidance' returns. Also, source_id is not explained, leaving the tool incomplete for an agent needing to call it with a specific source.

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 explains the probe parameter (tests an API with a public query/fetch and consumes quota), but provides no meaning for source_id, leaving a key parameter undocumented. This is a significant gap.

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

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

The description states a specific verb and resource ('Read coverage and safe setup guidance') and elaborates with the probe behavior (tests one API with a public query and fetch). It clearly distinguishes itself from siblings like search or fetch by focusing on status/coverage rather than data retrieval.

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

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

It conveys that the tool is for reading status and setup guidance, and the probe option is explicitly explained. However, it does not name alternative tools or state when not to use this tool, so it stops short of fully explicit routing guidance.

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

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

The annotations already declare readOnlyHint=true, openWorldHint=true, and destructiveHint=false. The description adds meaningful behavior beyond this: the hard limits on result count and depth (12 documents, depth 2) and the promise that unresolved links will be reported. No contradiction with annotations exists.

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

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

The description is a single, compact sentence with no filler. It front-loads the primary action, then the constraints, then the additional reporting behavior. Every part contributes meaning.

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

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

The tool has no output schema, so the description must explain what the agent can expect. It does mention that unresolved links are reported, but it does not clarify the return format, how source_ref and as_of_date interact, or the exact meaning of 'depth' relative to the depth_limit parameter (the schema default is 1, while the description says depth 2 is the maximum). This leaves noticeable gaps for a tool with three parameters.

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

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

Schema description coverage is 0%, so the description must compensate for undocumented parameters. It only hints at the depth_limit parameter by stating 'depth 2' is a maximum, but it does not explain the required parameters source_ref and as_of_date at all, leaving the agent without enough semantic grounding for the most important inputs.

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

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

The description names a specific verb ('Retrieve') and a specific resource ('explicit canonical cross-references'), adding concrete constraints ('at most 12 documents and depth 2') and a secondary behavior ('Report unresolved links'). This clearly differentiates the tool from siblings like search, fetch, and get_legal_version, none of which target cross-reference resolution.

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

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

The description implies when to use the tool: when canonical cross-references need to be resolved. However, it provides no explicit guidance on when not to use it or which alternative (e.g., search vs. fetch) would be more appropriate for a given scenario, leaving selection somewhat to inference.

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

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

Annotations already cover read-only and non-destructive behavior; the description adds that the tool inspects references/facts/dates/quotes/grounds/decisions and explicitly does not validate semantic support or law. It also mentions loading a methodology topic dossier, which is extra context not present in annotations. No contradiction 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?

Two short sentences, with the primary action front-loaded and no filler. The second sentence is slightly awkward ('Load methodology topic dossier for the contract') and could be clearer, but overall the description is economical.

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

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

For a tool taking a large nested dossier and returning no documented output, the description is serviceable but incomplete: it states what is checked and what is excluded, but it does not describe the result format, how results are reported, or exactly what 'Load methodology topic dossier' means. These gaps matter because there is no output schema to fill them.

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

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

The single `dossier` parameter has 0% schema description coverage, so the description must carry the semantic weight. It refers to the parameter as a 'structured justification' and names the components that will be checked, which helps the agent understand what shape/content matters. It doesn't enumerate every nested field, but the input schema supplies that structural detail.

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 concrete action ('Check') and a concrete object ('a structured justification'), and it lists the specific elements it verifies (referenced pieces, facts, dates, quotes, grounds, decisions). The scope is clear enough to distinguish it from a generic or semantic analyzer, though it never names a sibling tool explicitly.

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

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

The description implies usage when a caller wants to verify the structural integrity/completeness of a case dossier, and it explicitly says it does not validate semantic support or law. However, it gives no explicit 'use when' condition and names no alternative tools, so the agent must infer how it relates to check_evidence/evaluate_rule.

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 safety profile is known. The description adds two behavioral traits: the as_of_date constraint for consolidated texts, and 'Failed sources remain explicit,' which informs the agent of partial failure handling. This goes beyond annotations but only slightly.

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 extremely brief – three short phrases – which is efficient, but it reads like a fragment rather than a structured explanation. There is no clear organization, and the most critical information (what the tool returns) is absent. It is concise but not well-structured for agent consumption.

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

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

Given five parameters, one enum, no output schema, and a domain where search semantics matter (federated, official sources), this description is severely incomplete. It fails to explain the query behavior, pagination via cursor, legal_order filtering, source_types selection, or what the returned results look like. An agent would be guessing at most of the 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?

With schema_description_coverage at 0%, the description must compensate for the lack of parameter documentation. It only touches on as_of_date (and only partially – it doesn't say how the date is formatted or what happens without it). Query, cursor, legal_order, and source_types remain entirely unexplained, so the description fails to carry the load.

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 says 'Federated official search' but does not specify what is being searched (legal texts? case law? regulations?) or how it differs from siblings like search_case_law or search_local_acts. It is not a tautology, but it is vague and does not help an agent pick this over alternatives.

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

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

The description provides a single conditional guideline: 'Consolidated texts require as_of_date.' This tells the agent when to supply a parameter, but gives no context about when to prefer this federated search over the more specific sibling search tools, nor any exclusions or alternative routing.

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

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

Annotations already mark this as read-only and non-destructive. The description adds meaningful behavior beyond annotations: it reports batches and coverage, interprets zero hits as local-only, and requires following admin refs with fetch and then all evidence pages. No contradiction exists.

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

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

The description is compact and front-loaded. The first sentence gives scope and output behavior, and the rest adds filters and a concrete follow-up workflow. Every clause earns its place with no filler or repetition.

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

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

For a 5-parameter search tool with no output schema, the description covers the core scope, the key local-only edge case, and a required follow-up workflow. It could more explicitly define the return shape and what 'admin:' refs and evidence pages mean, but it is sufficient for an agent to invoke the tool correctly.

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

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

Schema description coverage is 0%, so the description must compensate for the input schema. It does add meaning to the courts parameter by expanding CE/CAA/TA and noting these filters are supported here. However, query, offset, date_start, and date_end semantics are left to inference from their names and types, with no added explanation of date-range inclusivity or offset behavior.

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

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

The description states a specific verb and resource: 'Search the operator-imported official XML subset.' It also clarifies the tool's output semantics ('Report batches and coverage; zero hits is local only') and the supported filters, which distinguishes it from sibling search tools.

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

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

The description provides clear context about when this tool applies: it searches the operator-imported official XML, supports CE/CAA/TA filters 'here', and tells the agent to follow admin refs with fetch then all evidence pages. It does not explicitly name alternative tools or exclusion conditions, but the 'here' and scope cues give adequate direction.

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

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

Beyond the readOnly/openWorld/destructive annotations, it discloses that administrative results come from CETAT and judicial from JudiLibre, that courts filtering is limited to the current JudiLibre taxonomy, that date bounds filter on decision dates rather than applicability, and that the corpus is not exhaustive. These are behavioral facts that materially affect result interpretation.

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

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

Four short, information-dense sentences with no filler; the most decision-relevant source mapping is front-loaded and caveats follow. Every sentence adds value.

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

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

Critical caveats for correct invocation and interpretation are present: source systems, legal-order routing, courts-filter limitation, date semantics, and non-exhaustive corpus. The main gaps are the unannotated query/cursor behavior and the lack of return-shape guidance, but these are less likely to cause mis-selection for a read-only search tool.

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

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

Schema description coverage is 0%, and the description compensates for legal_order (CETAT vs JudiLibre), courts (taxonomy limitation), and date bounds (decision dates). But query and cursor are left entirely unexplained, and date formats are not specified, so compensation is only partial.

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 never states 'searches case law' in a standalone verb phrase, but the tool name and source mapping ('Administrative order uses CETAT; judicial uses JudiLibre') make the scope clear. It is not a tautology, and the legal-order/source distinction helps separate it from broader search siblings, though it does not explicitly differentiate itself.

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 clear in-tool routing by legal order and a hard constraint on the courts filter ('only supports current JudiLibre taxonomy'), plus date semantics. It does not explicitly name alternatives or state when not to use the tool, so it stops short of a 5.

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

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

Annotations already indicate a safe, read-only, closed-world search, and the description adds useful context: the principal comes from operator config and dates should not be treated as evidence of legal validity. This helps the agent interpret results without contradicting 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 definition is two sentences with the main scope front-loaded and no filler. Both clauses earn their place: the 'only' boundary defines the tool, and the date caveat prevents a likely misinterpretation.

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 four parameters, no output schema, and zero parameter descriptions in the schema, the description is too thin to fully support correct invocation. It omits result format, parameter roles, and clear routing among the many sibling search tools, so the caveats alone are insufficient.

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 by explaining parameters like query, case_id, offset, and as_of_date. It only hints at date semantics and says nothing about the other three parameters, 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 states a specific action ('Search') and a specific resource scope ('authorized imported texts only'), which also differentiates it from the sibling search tools. It does not explicitly define 'authorized imported texts' or name alternatives, so it falls just short of a 5.

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

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

The word 'only' gives an explicit scope boundary, and the warning that 'dates do not imply valid local acts' provides practical guidance on interpreting results. It does not name an alternative sibling tool, so it is not fully explicit about when to choose another search.

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