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

The description discloses that the tool creates directories and mentions a default location with an optional root override. However, it does not explain behavior when directories already exist, whether the operation is destructive, or what 'root' resolves to in practice. Annotations do not contradict the description.

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

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

The description is a single, front-loaded sentence with no filler. It is concise, though slightly terse and arguably under-specified regarding label and root semantics.

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 two parameters manageable by an agent, the description omits the meaning of the required label, the exact output structure, and behavior on existing directories. The absence of an output schema makes this omission more impactful because the agent cannot infer return values elsewhere.

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 weight of explaining parameters. It vaguely references 'root' but does not explain the required 'label' parameter at all, leaving a critical gap in understanding what a case folder is named or structured.

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 action, 'Create inputs/ and artifacts/', and a clear target location, which distinguishes it from siblings like save_artifact or read_case_folder. It is somewhat ambiguous about how the required label relates to the resulting folder structure, but the core purpose is identifiable.

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

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

No guidance is provided about when to use this tool versus alternatives such as save_artifact or read_case_folder. There are no prerequisites, exclusions, or contextual cues beyond the bare statement of what the tool creates.

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 readOnlyHint, idempotentHint, and destructiveHint=false, so the safety profile is covered. The description adds non-obvious behavior: with no arguments the tool returns the orchestration script, while passing a persona changes the response to one persona's instructions. It does not address invalid persona values or error behavior, but the presence of an output schema and the read-only annotations lower the burden.

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

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

The description is two short sentences with no filler, and the most important fact ('Mandatory first call... returns the orchestration script') is front-loaded. The second sentence packs the only parameter semantics into a compact list. This is an appropriately sized 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 one-optional-parameter, read-only, output-schema-bearing tool, the description is largely complete: it covers call ordering, the no-argument default, and the valid persona set. The only notable gap is that the persona list is not explicitly bound to the agent_name parameter, though the schema's single property makes that inference easy. It does not need to describe return values because the output schema already covers 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 schema only defines an optional string agent_name with a default of '', so the 0% description coverage forces the description to carry the semantics. It does so by enumerating the acceptable persona values ('reader / format / drafter / verifier / refiner / overseer') and by stating that omitting arguments yields the orchestration script. It never explicitly names agent_name in the prose, but with a single parameter the mapping is inferable.

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: 'returns the orchestration script,' and clarifies that passing a persona ('reader / format / drafter / verifier / refiner / overseer') returns that persona's instructions. This is unique among the sibling tools, none of which mention orchestration scripts or persona instructions. It is slightly oblique because 'Mandatory first call' is more usage guidance than a purpose statement, so the core purpose is clear but not maximally 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?

'Mandatory first call' explicitly tells an agent to invoke this before anything else, which is strong when-to-use guidance. It also tells the agent the two calling modes: no arguments for the full orchestration script, or one persona for a persona-specific script. It does not mention when not to use it or name alternative sibling tools, but for an orchestration entry point that omission is minor.

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

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

Annotations already declare readOnlyHint=true, destructiveHint=false, and idempotentHint=true, so the safety profile is known. The description adds value by specifying the exact composition of the return (template, skill note, checklist) and the load order, which is behavioral detail beyond what annotations provide. It does not contradict any annotation.

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

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

The description is two sentences with no wasted words. The first sentence states the primary purpose, and the second provides the load order as supplementary detail. Information is front-loaded and 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?

Given the tool has an output schema (not shown but present), the return format is likely covered there. The description explains what the tool returns and gives a load order, which is useful context. It does not mention potential error conditions or prerequisites, but for a read-only, idempotent retrieval with a single parameter, this is adequate. The only gap is the lack of explicit parameter value guidance, which is already penalized under parameter semantics.

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

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

The input schema has one parameter (case_type) with 0% description coverage, so the description must compensate. The description only hints that 'one instrument' refers to the case type, but gives no details on acceptable values, format, or examples. This is minimal compensation for a completely undocumented parameter, so it scores low.

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: 'Return the long-form template + skill + user-facts checklist for one instrument.' This clearly distinguishes it from a plain template tool like get_template by enumerating the composite components. It does not explicitly name sibling alternatives, but the composite nature is unambiguous, so it scores just below a 5.

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

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

The description provides a load order (official template → skill note → common rules → Index/Synopsis sheets) and mentions 'for High Court filings,' which gives context on when the tool is relevant. However, it does not explicitly state when to prefer this tool over siblings like get_template or get_pleading_base, nor does it give exclusions. The usage guidance is implied rather than explicit.

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

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

Annotations already declare readOnlyHint=true, idempotentHint=true, and destructiveHint=false, covering the safety profile. The description adds the content structure (header, separator, annexure, paper) but no extra behavioral details such as authentication, rate limits, or side effects. With annotations in place, the description adds marginal value beyond them.

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

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

A single sentence with no filler, front-loading the primary action and resource. Every word earns its place, and the parenthetical list of output components is efficient and clear.

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

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

For a simple getter with one parameter and an existing output schema, the description is nearly complete: it states what the tool returns and hints at the content. The only missing piece is the semantics of forum_id, but given the low complexity and available output schema, the description is adequate.

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

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

The schema has a single parameter (forum_id) with zero schema description coverage (0%), and the tool description does not mention forum_id at all. Since the description must compensate for the missing schema documentation, and it does not, the agent receives no explanation of what forum_id represents, its format, or how it relates to the return value.

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

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

The description states a clear verb ('Return') and a specific resource ('forum-config exemplar') and even enumerates its parts ('header, separator, annexure, paper'). It is distinct enough to identify the tool's function, though it does not explicitly contrast with sibling tools like get_template or get_case_type_format, so it misses a full differentiation point.

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 the many sibling tools in the same ecosystem. There is no mention of prerequisites, context, or alternative tools, leaving an agent to infer the appropriate usage from the name alone.

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

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

Annotations already declare readOnlyHint, idempotentHint, and destructiveHint, so the safety profile is covered. The description adds only the 'shared' and jurisdictional context, not additional behavioral details such as return shape or content scope, but it does not contradict 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 description is a single, compact phrase with no filler or repetition. It is appropriately short for a zero-parameter read-only tool, though it could have used the spare space to add usage context.

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

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

For a zero-parameter tool with an output schema and read-only annotations, the description is mostly adequate. However, it lacks any guidance on when to choose this tool over sibling retrieval tools, leaving a meaningful gap in context despite the simple interface.

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

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

The tool has zero parameters, and schema description coverage is trivially 100%. With no parameters to document, the description does not need to add parameter-level semantics; the baseline of 4 applies.

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

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

The description names a specific resource: 'Shared Maharashtra pleading skeleton.' The tool name supplies the verb 'get,' and the domain/jurisdiction qualifier helps distinguish it from general template tools, though no explicit verb appears in the description 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?

No guidance is given about when to use this tool versus siblings like get_template, get_reference_note, or get_case_type_format. An agent must infer usage solely from the phrase 'pleading skeleton,' which is not enough to route correctly among many similar retrieval 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, idempotentHint, and destructiveHint, so the safety profile is covered. The description adds the list of valid names and alternative paths, which is useful context but not deep behavioral detail like error handling or return behavior.

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

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

The description is compact: a one-line purpose followed by a flat list of valid values. No wasted words, and the purpose is front-loaded.

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

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

With a single parameter, an output schema present, and the description listing all valid inputs, the tool is almost fully specified. Minor gaps remain (e.g., behavior on invalid names), but the description is adequate for correct invocation.

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

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

The schema has one parameter 'name' with zero description coverage. The description fully compensates by enumerating all valid names ('getting-started', 'harness', etc.) and alternative path forms ('docs/INSTALL', 'docs/HARNESS'), providing crucial semantic meaning beyond the schema.

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

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

The description states a clear verb ('Load') and resource ('packed reference'), and the name 'get_reference_note' aligns. It doesn't explicitly distinguish from siblings like get_template, but the resource type is unique enough that an agent can infer the tool's role.

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

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

No guidance on when to use this tool versus the many sibling tools. The description lists valid names but doesn't explain scenarios where this tool is preferred over alternatives, nor any 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 declare readOnlyHint=true, idempotentHint=true, and destructiveHint=false, so the safety and side-effect profile is covered. The description adds that lookup works by key or path, but it does not disclose behavior around formatting, missing keys, or fallbacks. 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 sentences with no filler: the operation is front-loaded, and examples are compactly presented. It does not repeat schema or annotation 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 simple, read-only, one-parameter tool with an output schema, the description provides the essential lookup semantics and examples needed to invoke it. Sibling-selection guidance is missing, but that gap is more directly a usage-guideline issue than an invocation-completeness issue.

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

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

The input schema only defines a required string 'name' with no description (0% coverage), so the description must carry the meaning. It explains that 'name' accepts either a case_type key or a relative path and gives concrete examples, which is enough for a single-parameter tool.

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

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

States a specific action ('Return') and resource ('long-form template') and clarifies the two lookup modes ('by case_type key or by relative path'). It is distinguishable from list_templates and get_pleading_base, but does not explicitly name a sibling to differentiate from.

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

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

No explicit when-to-use or when-not-to-use guidance is given, and no alternatives are mentioned. The examples only illustrate valid name formats; they do not tell an agent when to choose this over list_templates or get_pleading_base.

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

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

Annotations already declare readOnlyHint, idempotentHint, and destructiveHint=false, so the safety profile is covered. The description adds scope ('Maharashtra forums', 'can draft') but does not disclose return format, ordering, or other behavior. 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 a single, front-loaded sentence with the verb first and no filler. Every word contributes to identifying the tool's purpose and scope.

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 zero-parameter list operation, the description conveys the core purpose and scope. It could be slightly clearer by saying 'case types' instead of 'instruments' or noting what the returned list contains, but it is sufficiently complete for invocation.

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

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

The tool takes no parameters, and the schema is empty with 100% coverage. Per the zero-parameter baseline, no additional parameter explanation is needed; the description adds no parameter detail because none exists.

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 ('List') and resource ('instruments this connector can draft') with a clear scope ('Maharashtra forums'). It does not explicitly name sibling tools like list_forums or list_templates, but 'instruments' and 'can draft' distinguish it from those, making it clear though not fully differentiated.

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

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

The description implies the tool is for discovering what drafting instruments are available for Maharashtra forums, but it gives no explicit when-to-use guidance or exclusions versus siblings such as get_case_type_format or list_templates. The context is clear but alternatives are not discussed.

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

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

Annotations already declare readOnlyHint=true, idempotentHint=true, and destructiveHint=false, so the safety profile is covered. The description contributes the scope, but does not add further behavioral details such as ordering, pagination, or return format. 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?

A single sentence that starts with the action, names the exact resource, and contains no filler. Every word 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 zero-parameter, read-only list operation with rich annotations, the description plus sibling context is sufficient. It could clarify what a forum-config contains or what the response list looks like, but that is not critical for correct invocation.

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

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

The tool has zero parameters, so schema coverage is trivially 100%. The baseline of 4 applies because there is nothing for the description to clarify about parameters.

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

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

The description uses a specific verb ('List') and a specific resource ('Bombay benches and Maharashtra tribunal forum-configs'), which clearly distinguishes it from siblings like get_forum_config and resolve_bench.

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

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

The use case is implied: call it when you need an enumeration of Bombay benches and Maharashtra tribunal forum-configs. However, it does not explicitly mention alternatives or when not to use it, leaving the routing to inference from sibling names.

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

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

Annotations already declare readOnlyHint=true, idempotentHint=true, and destructiveHint=false, so the agent knows this is a safe, read-only operation. The description adds useful scoping (official, long-form, packed with connector), which tells the agent the tool will not return custom or short-form templates. It does not disclose response format or pagination, but given the strong annotations, this is acceptable.

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

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

A single, concise sentence that is front-loaded with the action ('List') and clearly scopes the resource. No filler, no redundancy. Every word 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 zero-parameter list tool with rich annotations, the description covers the essential purpose and scope. It could explicitly mention what the returned list contains (e.g., template IDs or names) or point to get_template for detailed retrieval, but the current wording is sufficient for an agent to invoke the tool correctly. The absence of an output schema is partially mitigated by the sibling context.

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

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

The tool has zero parameters and the input schema is an empty object. There is no parameter information for the description to add beyond what the schema already states, so the baseline of 4 applies. The description's focus on scope rather than parameters is appropriate.

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

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

The description uses a specific verb ('List') and resource ('every official long-form template packed with this connector'), which clearly distinguishes it from sibling tools like get_template (which likely fetches a single template) and list_forums/list_case_types (different resource types). An agent can immediately understand the tool's scope.

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

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

The intended usage is implied: use this tool when you need an enumeration of all official long-form templates shipped with the connector. However, the description does not explicitly contrast it with alternatives such as get_template for fetching a specific template, nor does it state exclusions (e.g., non-long-form or custom templates). Usage is clear but not actively guided.

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

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

Annotations already declare readOnlyHint=true, idempotentHint=true, and destructiveHint=false, covering the safety profile. The description adds useful scope context but does not disclose return format, recursion behavior, or error handling. It adds some value beyond annotations without contradicting them.

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

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

The description is a single, front-loaded sentence with no filler. It states the action and scope directly and earns its place without redundant wording.

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

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

For a simple read-only tool with one parameter and helpful annotations, the description is minimally adequate: it identifies file types and directories. However, it omits details an agent might need, such as what the tool returns, how case_folder should be expressed, and whether the read is recursive. The lack of an output schema increases the need for such context.

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

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

The only parameter, case_folder, has 0% schema description coverage, so the description carries the full burden of explaining it. It does not define the parameter's format, path structure, or required value, and only loosely implies it selects a folder under inputs/ and artifacts/. This is insufficient compensation for the schema gap.

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

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

The description uses a specific verb ('Read') and names concrete resources ('md / txt / pdf / docx under inputs/ and artifacts/'), making the tool's purpose clear. It does not explicitly name sibling tools to differentiate them, but the file-scope is specific enough to avoid obvious confusion with list_forums or get_agent_instructions.

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 an agent needs to read supported file types from a case folder's inputs/ or artifacts/ directories. It provides no explicit exclusions or alternative tool names, so an agent must infer which sibling tools to prefer in related scenarios.

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

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

Annotations already declare readOnlyHint, idempotentHint, and destructiveHint, covering the safety profile. The description adds the Kolhapur circuit rule and the list of forum_family values, but does not disclose return format, error behavior, or other operational details. Given annotation coverage, this is adequate but not rich.

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

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

The description is concise, with the primary purpose front-loaded and the special rule appended. It avoids unnecessary words and is easy to scan, though the format is a bit unstructured (line breaks used for emphasis).

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

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

With no output schema, the description should explain what the tool returns (e.g., a bench identifier, name, or location). It does not describe the result for typical districts or handle edge cases beyond Kolhapur. The special rule is helpful, but the overall behavior and return value are underspecified for an agent to rely on.

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 forum_family with allowed values, which adds meaning, but it does not clarify the district parameter (format, examples, or constraints) nor what the output will be. This is a significant gap for a 0% coverage tool.

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

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

The description states a specific action ('Map a Maharashtra district to the correct Bombay bench, MAT bench or DRT') with a clear resource and target. It is distinct from sibling tools like list_forums or get_forum_config by its focus on resolving a bench from a district, though it does not explicitly name 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?

It provides a specific rule for Kolhapur-circuit districts, indicating when a special check is needed. However, it does not explicitly state when to prefer this tool over siblings (e.g., when to use resolve_bench instead of list_forums), leaving the selection largely implied by the purpose.

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 this is a non-read-only, non-destructive, idempotent operation. The description adds the 'allow-listed' constraint and 'case folder' destination, but does not disclose overwrite behavior, validation rules, or what happens when the artifact is not allow-listed. It is consistent with annotations and adds modest context.

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

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

The description is a single, front-loaded sentence with no redundant wording. Every word contributes meaning, and the core action and target are immediately clear.

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, no parameter descriptions, and only minimal annotation coverage, the description is too sparse for an agent to call this tool correctly in all cases. It does not explain what 'allow-listed' means, what content should contain, filename constraints, or the expected result of the save operation.

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

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

Schema description coverage is 0%, so the description must compensate for the three undocumented parameters. It clarifies the general purpose of case_folder but does not explain the expected format or semantics of content or filename, leaving the agent to infer from property names 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 states a specific verb ('Save'), a specific resource ('allow-listed pipeline artifact'), and a target location ('case folder'). This clearly differentiates it from siblings like save_draft_as_docx and read_case_folder without needing to inspect 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?

The phrase 'allow-listed pipeline artifact' implies a precondition for use, but the description does not explicitly state when to use this tool versus alternatives such as save_draft_as_docx or create_case_folder. Usage context is implied rather than stated.

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

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

The description adds little beyond the annotations. Annotations already indicate idempotentHint=true and destructiveHint=false, but the description does not disclose behavior like overwriting existing files, whether the source markdown is modified, or any side effects. The mention of 'pandoc' is technology detail, not behavior.

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

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

The description is a single, compact sentence with no extraneous words. It front-loads the core purpose and is appropriately minimal.

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

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

With three parameters, no output schema, and minimal annotation, the description does not provide enough context for an agent to correctly invoke the tool. It omits explanations of case_folder, output_filename, and markdown_filename, and does not describe expected behavior or error conditions.

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 missing parameter meanings. It does mention 'markdown draft' and 'docx', which hints at the roles of markdown_filename and output_filename, but it does not clearly explain each parameter or their defaults. This is insufficient compensation.

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

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

The description clearly states the verb 'Render' and the resource 'a markdown draft to a filing-grade docx via pandoc', which is specific and unambiguous. However, it does not explicitly differentiate itself from sibling tools like save_artifact, so it falls short of a 5.

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

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

No guidance is provided on when to use this tool versus alternatives such as save_artifact or other conversion tools. The description only states what it does, leaving the agent to infer usage context on its own.

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