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

Annotations already declare readOnlyHint=true and destructiveHint=false, so the description's burden is lower. It adds the chaining behavior (returned GUID/id for next branch) and specifies current-price stages, which are useful behavioral details that go beyond the annotations. No contradictions.

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

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

The description is concise for its density, packing navigation rules, source-specific constraints, and stage lists into a few sentences. It front-loads the core action and then provides necessary details without fluff. Slightly longer than ideal but each 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?

Given the tool's complexity (9 params, no output schema), the description covers the key usage pattern and parameter semantics. It lacks explicit details on pagination semantics, archive behavior, or response structure, but the core goal of browsing a tree is well-supported. An agent could make a correct first call and know how to continue.

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%, so the description must carry the parameter meaning. It explains parent, level, section (with TER ranges), and the keys accepted in source_params. It does not explicitly cover page/limit/offset/archive, but those are standard pagination and archival flags that an agent can infer. This is a strong compensation for an undocumented 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 specific verb ('Navigate') and resource ('named FGIS source tree'), and explains the recursive navigation pattern using returned GUID/id as parent. It is clear what the tool does, but it does not explicitly differentiate from siblings like fgis_catalog or fgis_search_norms, relying on the term 'browse' to imply hierarchical traversal.

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 direct usage instructions: 'Use returned GUID/id as parent and level for next branch.' It also provides source-specific conditions ('registry uses section + page; TER sections are 6 and 7') and lists supported source_params keys. While it doesn't state when NOT to use this tool versus alternatives, the context is sufficient for an agent to apply it correctly.

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 only say the tool is not read-only and not destructive. The description adds meaning by specifying 'cooperative cancellation after the current request/import' and 'preserve downloaded data,' disclosing timing and data-safety behavior. It does not detail post-cancel job state, but that is a minor gap given 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 front-loads the operation and then adds the two most important qualifiers: cooperative and data-preserving. 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 simple one-parameter tool with annotations, the description covers what it does and its key side-effect behavior. It doesn't specify return values or error conditions, but no output schema exists and the tool is simple enough that this is a minor omission.

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 never mentions job_id, its format, or how to obtain it. The one required parameter is documented only by name/type, so the description adds no semantic value for parameters beyond the obvious inference.

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?

Description says 'Request cooperative cancellation after the current request/import; preserve downloaded data,' giving a specific verb, resource, and behavioral qualifier. It clearly separates this tool from job-status/read sibling tools and from fgis_resume_job.

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 cooperative/timing language implies this is for gracefully stopping an in-flight job/import while keeping downloaded data. However, there are no explicit when-to-use/when-not-to-use conditions or references to alternatives such as fgis_resume_job or fgis_job_status.

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 openWorldHint, so the description's job is lighter. It does add useful hierarchical filtering behavior, indicating that zones inherit a region parent and periods inherit a zone parent, but it does not disclose pagination, result shape, or invalid parent handling.

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. The semicolon-separated structure efficiently packs the hierarchy into a scannable format.

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 no output schema and 0% parameter coverage, the description is too thin for an agent to construct a fully correct call. It omits explicit `kind` literals, per-kind `parent_id` semantics, and what the returned list items look 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%, so the description must compensate. It suggests that `parent_id` filters zones by region and periods by zone, but it never explicitly maps `kind` to 'regions', 'zones', or 'periods', nor does it state how `parent_id` behaves when listing regions. Exact accepted values are left to inference.

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

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

The description clearly states a listing operation for price regions, zones, and periods, with an explicit parent-child hierarchy. It is specific enough to distinguish fgis_catalog from the broader sibling tools, though it never explicitly names the `kind` values.

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

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

There is no guidance about when to use this tool instead of siblings like fgis_sources, fgis_list_datasets, or fgis_browse_source. The hierarchy hint implies usage, but no explicit context or exclusions are provided.

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

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

Annotations already declare readOnlyHint=true and destructiveHint=false, and the description's 'read' aligns with those. It adds a little context by listing the kinds of information returned (counts, coverage, manifest, local paths), but it does not disclose error behavior, return format, or what happens for invalid dataset IDs.

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

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

A single, front-loaded sentence that efficiently communicates the tool's core function and the main data categories returned. Every word 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?

The description is adequate for a simple read-only info tool with one parameter, especially with annotations covering safety. However, it lacks usage context versus siblings and does not explain return value structure or parameter semantics, leaving some gaps for an agent deciding how to invoke it.

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

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

Schema description coverage is 0% and the description does not explain the dataset_id parameter beyond its name. Since the ID is a single obvious parameter it is not as severe as a multi-parameter case, but the description still fails to add meaning such as expected format, source, or how to obtain valid IDs.

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

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

States a clear verb ('read') and resource ('dataset info') and enumerates the specific content returned: counts, coverage, manifest, and local artifact paths. This distinguishes it from data-query tools like fgis_query_dataset, though it doesn't explicitly name sibling 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?

No guidance is given about when to use this tool versus siblings such as fgis_list_datasets, fgis_query_dataset, or fgis_catalog. The read action is implied, but there are no explicit conditions, exclusions, or alternative recommendations.

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=true, and destructiveHint=false, so the safety profile is covered. The description adds that the tool uses a configured route and focuses on proxy vs full-tunnel VPN limitations, which is consistent with the annotations but does not go deeper into result format, external requests, or potential variability.

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, tight sentence with no filler. It front-loads the action ('Check FGIS API JSON') and then concisely states the secondary explanatory purpose, so 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?

For a zero-parameter tool with no output schema, the description covers the core action and context. However, it does not describe the expected output format, when exactly to run the diagnostic, or what the limitations of the diagnostic itself are. The low complexity keeps it adequate, but there are clear informational 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?

The tool has zero parameters and schema coverage is 100%, so the baseline is 4 per the rubric. The description adds value by indicating the tool relies on a configured route rather than user-supplied parameters, which clarifies why no inputs are needed.

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 identifies a specific verb ('Check') and resource ('FGIS API JSON via configured route'), and adds that it explains proxy vs full-tunnel VPN limitationstas. This makes it clearly a diagnostic tool rather than a data-access tool, though 'check' could be more explicit about what check entails, preventing 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 implies this tool is for diagnosing API connectivity/route issues and VPN configuration limitations. However, it does not explicitly state when to use it over alternatives, prerequisites, or when not to use it. The sibling names suggest it is unique, but the usage guidance is only implicit.

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 read-only/non-destructive, and the description adds meaningful behavior: offset/next_block_offset paginate blocks rather than text characters, and the result is raw source structure. This is valuable beyond the annotations, though it doesn't describe result ordering or empty-result behavior.

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

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

Three tight sentences, front-loaded with the core list, followed by pagination caveat and a routing note. Every sentence earns its place; no filler.

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

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

For a read-only listing tool with no output schema, the description is mostly complete: it names the content, the pagination model, and the relationship to fgis_read_document_table. The main gap is the unexplained optional parameters, but those are likely shared patterns in the fgis family.

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 and five parameters, the description must compensate but only explains the offset/next_block_offset semantic. It does not explain source, document_guid, expected_sha256, or the limit parameter's role, leaving substantial ambiguity.

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 opens with a specific verb-resource pair: 'List document paragraphs, explicit HTML headings and tables with text offsets and previews.' It then distinguishes itself from an 'inferred official table of contents,' which separates it from any sibling that might provide a high-level TOC.

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 usable context: this is source structure, not an inferred official table of contents, and table indices feed fgis_read_document_table. It stops short of naming an explicit alternative for the inferred-TOC case, so it earns 4 rather than 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?

The description adds useful behavior beyond the annotations: it states that SQLite always existschers, that files and hashes are returned, and that exports can be JSONL and/or Parquet. It does not disclose details like file locations or whether the operation is synchronous, but it meaningfully supplements the sparse 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 exceptionally concise: two sentences with no filler. The primary action is front-loaded, and the second sentence adds behavioral details (SQLite presence, returned files and hashes) with zero waste.

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

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

The description is reasonably complete for a 2-parameter tool, mentioning output types and returned artifacts. Yet it does not clarify the meaning of 'stopped', the output structure, or what happens when formats is absent, so some essential context for a new agent is missing.

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

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

With 0% schema coverage, the description carries the parameter documentation burden. It enumerates the possible format values ('jsonl' and 'parquet') and implies multiple selections via 'and/or', but it leaves dataset_id implicit and does not explain the default behavior when formats is null.

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 ('Export') with a clear resource ('stopped dataset') and targets ('jsonl and/or parquet'), making the tool's core purpose evident. It is unique among the sibling tools, but does not explicitly differentiate itself from reading or querying operations.

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 'stopped dataset' implies a prerequisite for use, giving some contextual guidance. However, it does not state when to prefer this tool over alternatives like fgis_query_dataset or fgis_read_dataset_document, nor does it mention exclusions.

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

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

Annotations already declare readOnlyHint=true and destructiveHint=false, and the description's 'Read' aligns with that. It adds useful context about what status aspects are covered (progress, failed tasks, interruption state), but it does not disclose error behavior, job lifetime, or whether results are valid only while a download is active. 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, tightly worded sentence that front-loads the action and object. Every word adds meaning, with no filler, redundancy, or tangential detail.

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

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

For a simple one-parameter, read-only status tool, the description covers the core purpose and the annotations cover safety. However, it lacks guidance on where job_id comes from, what the response looks like, and any caveats about polling or completion. There is no output schema to fill that gap, so some completeness is missing.

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

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

Schema description coverage is 0%: job_id is just a string with no documented format or origin. The description only implicitly ties it to a background download; it doesn't explain where to obtain it or any constraints. The description does not adequately compensate for the bare 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 uses a specific verb ('Read') and identifies the exact resource ('background download') and the information returned: progress, failed tasks, and interruption state. This clearly separates it from sibling actions like fgis_start_download, fgis_cancel_job, and fgis_resume_job.

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 checking on a background download, but it does not explicitly state when to use this tool versus alternatives, nor does it mention prerequisites such as obtaining a job_id from fgis_start_download. The read-only intent is clear, but no active guidance or exclusions are provided.

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

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

Annotations already declare readOnlyHint=true and destructiveHint=false, and the description adds meaningful behavioral context beyond that: this tool reads locally stored data and makes no network call to FGIS. This is useful operational information not present in the annotations. Minor gaps such as pagination behavior remain, but the annotations lower the bar.

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

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

The description is a single front-loaded sentence with no filler. Every word contributes either the scope ('locally stored datasets') or the key behavioral distinction ('without contacting FGIS').

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 list tool with two optional pagination parameters, the description covers purpose and the core network behavior while annotations cover safety. It does not describe the exact return shape, and there is no output schema, but the operation is simple enough that this is a minor gap.

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

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

Schema description coverage is 0%, and the description adds no explicit meaning for 'limit' or 'offset.' The parameter names and defaults give a conventional pagination hint, but the description does not compensate for the lack of parameter documentation.

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 and resource: 'List locally stored datasets.' It also adds a key differentiator, 'without contacting FGIS,' which separates this tool from sibling tools that operate against the remote FGIS system. An agent can understand exactly what this tool 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?

The phrase 'without contacting FGIS' gives clear context that this is the local, offline listing option, effectively routing an agent away from remote data tools. It does not explicitly name alternatives or state when not to use it, 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 mark it read-only and non-destructive. The description adds behavioral value by revealing that document hits are summaries and that full content requires a separate tool, which an agent would not know from the schema or 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, front-loaded with purpose, no fluff.

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

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

The tool has 8 parameters, no output schema, and no schema-level parameter descriptions. The description omits required parameter semantics, result shape, pagination, and how 'offline' behaves, leaving an agent under-informed 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?

With 0% schema description coverage and 8 parameters, the description should compensate but only hints at resource categories (norms/prices/documents), which likely maps to `kind`. It provides no meaning for `code`, `query`, `limit`, `offset`, `zone_id`, `period_id`, or `dataset_id`.

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 purpose: offline search over norms/prices/documents, and notes that documents return summaries. This differentiates it from full-content readers, though it does not explicitly distinguish it from fgis_search_norms or fgis_search_document.

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 context that it is an offline search and tells the agent to use a document tool for full content. It does not give explicit when-to-use vs when-not-to-use criteria relative to sibling search tools, leaving the choice partly inferred.

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 covered. The description adds useful behavioral context: 'bounded character pages' indicates pagination behavior and 'no network' indicates offline operation. It does not disclose details like whether offset/limit are required or how page boundaries behave, but it adds some value beyond 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 concise sentence that front-loads the core action and key constraints. It is efficient and avoids redundancy, though it could add a bit more parameter context without becoming bloated.

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 paginated tool with annotations covering safety, the description is adequate but not complete. It lacks explicit guidance on parameter semantics and does not mention return format or how to use offset/limit effectively. Given the 0% schema coverage and no output schema, a bit more detail would be warranted.

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

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

Schema description coverage is 0%, so the description carries the burden of explaining parameters. The description mentions 'bounded character pages' which hints at limit/offset semantics, but it does not explain dataset_id or document_id, nor does it clarify how limit/offset interact with the pagination. With 0% coverage, the description should compensate more.

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 ('Read') and resource ('saved complete source JSON/technical parts') and adds a scoping constraint ('in bounded character pages; no network'). It is clear enough to distinguish from generic read tools, though it does not explicitly name a sibling alternative.

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 for reading saved source JSON/technical parts without network access, which gives some context. However, it does not explicitly state when to use this tool versus siblings like fgis_read_document or fgis_browse_source, nor does it provide 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?

The description adds substantial behavior beyond the readOnly/openWorld/destructive annotations: 15-minute RAM cache, refresh semantics, offset as text characters, expected_sha256 integrity guarding, and no OCR for embedded images. There is 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?

The description is dense but purposeful; each sentence adds useful operational detail such as cache behavior, integrity checking, and OCR limitations. It is front-loaded with the core action and then provides necessary constraints. Some domain abbreviations (FSNB/FER/methods/PIR) assume prior context but are tied to browse output.

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 tool with six optional parameters and no output schema, the description covers selection, caching, freshness, integrity, offset semantics, and a key limitation (no OCR). It does not describe the return payload shape, but the 'as text' framing and offset guidance make the missing detail acceptable.

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 parameter semantics. It explains source values, document_guid usage, expected_sha256, offset units, and refresh behavior. It does not explicitly describe 'limit', but its meaning is reasonably inferable from the pagination context.

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 identifies the resource ('public document/technical part online as text'). It also distinguishes itself from sibling tools by explicitly excluding dataset/disk-cache reads and pointing to the table tool for structured cell extraction.

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 concrete when-to-use direction: draw document_refs from browse, use source='normative' + GUID for certain documents, and use source='fssc'/'fsem' without GUID for full documents. It also points to the table tool for tables. It does not explicitly name sibling read tools as alternatives, but the routing guidance is clear enough.

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?

Even with annotations declaring readOnlyHint and openWorldHint, the description adds substantial behavioral detail: merged cells are not expanded, each row paginates physical source cells, long previews are explicitly truncated, and the tool returns surrounding text without inferred applicability. This goes well beyond the annotation safety profile and clarifies exactly what the call will and won't return.

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 sentences, each carrying distinct value: what it reads, how to identify the table, how pagination works, and how to handle truncation. No filler or repetition. The most important operational directive ('Get table_index from outline') appears early.

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 8 parameters, no output schema, and only partial parameter documentation in the description. It gives enough context to use table_index and cell pagination, but not enough to know how to obtain or set document_guid and expected_sha256, or what the response structure looks like. For a read-only table reader with a companion workflow, this is adequate but not fully self-contained.

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 explain table_index ('Get table_index from outline') and the cell_offset/cell_limit pagination pattern, but it omits meaning for limit, row_offset, source, document_guid, and expected_sha256. An agent would not know what document_guid refers to or how source is selected, leaving most parameters underspecified.

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-resource pair, 'Read source table rows/cells online', and scopes it with details like preserving header flags, rowspan and colspan. It implicitly distinguishes itself from fgis_read_document (full document text) and fgis_document_outline (table index discovery), and even notes what it does not do (no inferred price or coefficient applicability). An agent can tell this is the table-reading companion to the outline tool.

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 clear prerequisite: 'Get table_index from outline.' It also explicitly routes truncated cells to read_document. However, it does not enumerate when to prefer this tool over fgis_read_document or fgis_read_dataset_document, and the 'no inferred price or coefficient applicability' is more of a boundary than a usage guideline. Still, the workflow guidance is concrete and actionable.

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=true, and destructiveHint=false, so the safety profile is covered. The description adds that it returns 'work steps and original resource quantities', which is useful behavioral context beyond the schema. It does not disclose pagination behavior or what happens when the code is not found, but the 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 a single, front-loaded sentence that names the resource and the key included content. It is efficient and avoids redundancy with the schema. It could add a bit more detail about parameters without becoming bloated.

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

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

For a read-only tool with annotations covering safety and no output schema, the description is mostly adequate. However, with 0% schema coverage and three parameters, it should explain limit/offset and possibly the return format. The core purpose is clear, but an agent might not know how to paginate or what the response contains beyond the mentioned fields.

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 parameters. It explains the 'code' parameter implicitly (the norm code to read) but says nothing about 'limit' and 'offset' semantics. The description adds minimal meaning beyond the schema's bare property names.

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 ('read') and resource ('exact bare norm code online'), and adds scope details ('work steps and original resource quantities') that distinguish it from generic read tools. It does not explicitly name a sibling alternative, but the phrase 'exact bare norm code' implies a precise lookup distinct from search_norms or read_document.

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: use this when you need the exact norm code content, not search results or documents. However, it does not explicitly state when not to use it or name alternatives like fgis_search_norms or fgis_read_document. The context is clear enough for a basic read operation but lacks 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?

Annotations already declare readOnlyHint=false, destructiveHint=false, and openWorldHint=true, so the description doesn't need to restate those. The description adds useful behavioral context: it verifies saved source hashes and retries uncommitted tasks, implying a stateful operation that may mutate job state. However, it does not disclose what happens if hashes mismatch, whether it can partially succeed, or whether it may start new downloads. With annotations covering the safety profile, a 3 is appropriate.

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

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

The description is a single concise sentence that front-loads the primary action ('Resume a stopped/partial job') and then adds two specific behavioral details. Every phrase earns its place. It could be slightly more structured (e.g., separating the action from the verification step), but it is efficient and readable.

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

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

For a stateful resume operation with no output schema and zero parameter documentation, the description is incomplete. An agent needs to know what job_id refers to, how max_tasks behaves, what the return value looks like, and what happens on hash mismatch or failure. The description covers the high-level behavior but leaves critical operational details unspecified.

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 two parameters. It does not explain what job_id should look like (format, where to find it) or what max_tasks controls (limit on retried tasks? total tasks? null meaning?). The description's mention of 'retry uncommitted tasks' hints at max_tasks but does not explicitly map it. This is a significant gap for a tool with zero schema coverage.

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

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

The description states a specific verb ('Resume') and resource ('stopped/partial job'), and lists concrete actions: verify saved source hashes and retry uncommitted tasks. This clearly distinguishes it from sibling tools like fgis_job_status (status check) and fgis_cancel_job (cancellation). It could be slightly stronger by naming a sibling explicitly, but the verb+resource+actions are clear.

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

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

The description implies usage: use when a job is stopped/partial and you want to retry uncommitted tasks. It does not explicitly state when not to use it or name alternatives, but the context of resuming a job is reasonably clear. It lacks explicit guidance on prerequisites (e.g., job must exist, must be in a resumable state) or when to prefer fgis_job_status or fgis_cancel_job instead.

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

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

Annotations already declare the tool read-only and non-destructive, so the description adds substantial behavioral detail beyond them: literal case-insensitive matching, whitespace matching across paragraph/cell boundaries, return of excerpts/offsets/next_offset, and the text_status caveat. There is no contradiction with 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?

Six dense sentences, each carrying distinct operational value: scope, matching edge behavior, return payload, cross-tool navigation, exclusions, and an edge-case warning. The most important purpose is front-loaded and there is no filler.

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

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

With no output schema, the description competently describes return values, pagination, follow-up reading, and the no-match caveat. It is nearly complete for the primary single-query workflow, though a few parameter semantics are left implicit.

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 query semantics and pagination/offset behavior, but it does not address limit, context, source, document_guid, or expected_sha256 beyond what their names and defaults imply. It adds meaningful value but does not fully document all seven 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 opens with a precise verb and resource: 'Find literal case-insensitive text within one public document, without a dataset.' This clearly distinguishes it from sibling tools like fgis_query_dataset and fgis_search_norms by specifying exact scope, matching mode, and document-level targeting.

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 explicitly names read_document as the follow-up tool and describes the pagination handoff via returned offsets. It also gives strong exclusion guidance: 'No semantic search, coefficient selection or inference', and warns to check text_status before interpreting no matches.

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

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

With readOnlyHint=true, openWorldHint=true, and destructiveHint=false already declared, the description adds value by disclosing that the target is a public API (suggesting no special auth needed) and that every source publication is returned as a card, revealing output granularity invisible in the schema. This context goes beyond what the annotations alone 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?

Two short sentences totaling 14 words, with the verb and resource front-loaded and no wasted words. The return-value clause earns its place by clarifying output granularity.

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 search with three self-explanatory parameters and safety annotations, the description covers the operation, query mechanism, and return shape, and the absence of an output schema makes the 'returns cards' note valuable. The notable gap is the lack of any routing guidance against the near-identical sibling fgis_search_document.

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 that the required 'query' parameter accepts a code or text, but 'limit' and 'offset' receive no explanation beyond their self-evident names and defaults. The compensation is partial — the core parameter is clear, but pagination format and search-matching behavior are left undocumented.

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 ('Search'), a resource ('public norm API'), and a search mechanism ('by code/text'), and it states the return shape ('cards for all returned source publications'). It does not explicitly distinguish itself from the sibling fgis_search_document, so it stops short of the top score.

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 its usage context — searching public norms by code or text — but it never says when to choose this over fgis_search_document, fgis_read_norm, or other siblings, and it offers no exclusions. The selection logic must be inferred from the tool name and sibling list.

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 only restates the tool's content and does not describe behavior such as read-only-ness, side effects, or response format. Annotations already declare readOnlyHint=true and destructiveHint=false, so there is no contradiction, but the description adds no behavioral context beyond those hints.

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 line with a plain list; every word carries information and the main content is front-loaded. Nothing extraneous is present.

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, the list of catalogues is mostly sufficient, but since there is no output schema, the description does not explicitly state what the tool returns or how the values connect to sibling tools like fgis_browse_source or fgis_catalog. It is minimally adequate but has 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?

The input schema has zero parameters, so the baseline is 4. The description does not need to elaborate on parameters and does not do so.

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 tool as a source/catalogue listing and enumerates the specific catalogues (FSNB, FER, TER registry, etc.). It lacks an explicit verb like 'lists' or 'returns', and it does not differentiate itself from sibling tools such as fgis_catalog or fgis_browse_source.

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

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

There is no explicit guidance on when to use this tool instead of alternatives. The phrase 'Available catalogues' implies it is an entry point for discovering catalogues, but the description never states conditions, exclusions, or how it relates to fgis_catalog or fgis_browse_source.

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 discloses several behaviors beyond the annotations: no automatic all-Russia/history download, bulk archive files require interactive portal CAPTCHA, TER registry is not TER table content, search enumeration cannot establish exhaustive FSNB coverage (consistent with openWorldHint=true), bounded jobs retain pending tasks, and the return of a job/dataset ID. These are genuinely useful caveats that align with, rather than 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 run-on wall of text where semicolons jam unrelated clauses together (e.g., '['all_public'] selects all adapters; include_archive adds archived legal trees; all_periods includes historical split forms'). Only the opening sentence is properly front-loaded; the rest lacks separation between purpose, parameter semantics, and warnings. Information-dense but poorly organized.

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 7-parameter tool with no output schema and 0% schema coverage, the description carries a heavy burden and covers most parameters, the return value, and key caveats. But the disorganized structure and lack of explicit parameter-name mapping mean an agent could misapply the hints, and there is no guidance on behavior when all parameters are left null (0 required). Information is present but hard to reliably extract.

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, and it substantially does: collections (each scans 01..99), price_books structure [{zone_id,period_id}], sources from fgis_sources, include_archive (archived legal trees), all_periods (historical split forms), and max_tasks (bounds traversal). However, the mapping is loose prose requiring the agent to parse which clause corresponds to which parameter name, so it doesn't fully compensate for the coverage 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 opens with 'Start durable download', a clear verb+resource that identifies the action. It is distinguishable from siblings like fgis_job_status, fgis_cancel_job, and fgis_resume_job which manage jobs rather than initiate downloads. However, the purpose gets buried under a dense stream of parameter hints and warnings, diluting the clarity slightly.

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 guidance or alternatives are given. The description references fgis_sources ('sources from fgis_sources traverses actual catalogues') but never explains when an agent should start a download vs browse sources first or query an existing dataset. There are no exclusions or conditional routing rules, leaving the agent to infer usage context.

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