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

Beyond the annotations (which only say not read-only and not destructive), the description reveals a stateful precondition: the target list must be open and the stack cache needs an item. This is useful hidden behavior. It stops short of describing failure behavior or exact insertion semantics.

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 concise sentences with the core action front-loaded and useful prerequisites in the second sentence. A minor redundancy exists because 'inserts new list items' restates 'Add list items', keeping it a 4 rather than a 5.

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 key stateful requirement is mentioned, but the description relies on the unexplained 'stack cache' concept and never ties the tool to the open_list_in_docling_document lifecycle. An agent could infer the ordering, but the description itself leaves that 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 100%, so the schema already documents document_key, list_items, list_item_text, and list_marker_text. The description mentions 'specified text and marker' but adds no meaning beyond the schema, matching the baseline.

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 ('Add'), a concrete resource ('list items'), and a precise target ('open list in an existing document in the local document cache'). This clearly separates it from sibling tools like open_list_in_docling_document, close_list_in_docling_document, and add_paragraph_to_docling_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?

It states the context clearly: the document must already exist, the list must be open, and the document's stack cache must contain at least one item. It does not explicitly say 'call open_list_in_docling_document first' or list exclusions, so it is not a perfect 5.

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

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

Annotations already indicate this is a mutating operation (readOnlyHint=false, destructiveHint=false). The description adds that the paragraph is inserted 'under the specified section header and level,' but the input schema has no parameters for a section header or level, making this claim confusing and under-specified. No further behavioral detail is provided about positioning, ordering, or side effects.

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 short and front-loaded, with the core action in the first sentence. However, the two sentences are somewhat redundant: 'existing document in the local document cache' and 'already been processed and stored in the cache' convey nearly the same 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?

An output schema exists, so return-value details are not necessary here. However, the description references a 'specified section header and level' without explaining how those are supplied, since neither appears in the input schema. It also does not indicate how the paragraph anchors to existing document structure, leaving an important invocation gap for a mutation tool in a large sibling 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?

Schema description coverage is 100%, so the schema already documents both parameters. The description reinforces that document_key identifies a cached document and paragraph is the text content, but adds no additional formatting, syntax, or location semantics beyond what the schema provides.

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 and resource: 'Add a paragraph of text to an existing document in the local document cache.' It also mentions placement 'under the specified section header and level,' which helps distinguish it from sibling tools that add titles, headings, or list items, though it does not explicitly contrast them.

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

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

The description gives a clear precondition: the document must already be processed and stored in the cache. However, it does not state when to prefer this tool over sibling tools like add_section_heading_to_docling_document or add_list_items_to_list_in_docling_document, nor does it provide any explicit when-not-to-use 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 indicate readOnlyHint=false and destructiveHint=false, so the safety profile is known. The description adds that the tool 'inserts' a heading into an existing cached document, which is useful. However, it does not explain where the heading is inserted, whether it appends at the end, or how it interacts with existing document structure.

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

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

The description is compact and front-loaded with the core purpose. The additional sentences clarify the cache prerequisite and heading-level semantics without unnecessary verbosity. Every sentence earns its place.

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

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

For a simple three-parameter mutation tool with an output schema and clear annotations, the description adequately covers the purpose, prerequisite, and heading-level behavior. The main missing detail is insertion position, but this is a minor gap given the tool's simplicity and the availability of structured schema information.

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 100%, so the schema documents all parameters well. The description adds a small clarification that section levels represent heading hierarchy with examples like H1 and H2, but most parameter meaning is already present in the schema. This matches the baseline for high 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 action and resource: 'Add a section heading to an existing document in the local document cache.' It is clear this tool modifies an existing Docling document by inserting a heading. It does not explicitly differentiate itself from sibling tools like add_title_to_docling_document, but the term 'section heading' and the concept of heading levels provide enough distinction for a clear purpose.

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

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

The description clearly indicates that this tool is for documents 'already been processed and stored in the local cache,' establishing the prerequisite context. It does not explicitly name alternatives or exclusions, but the context is clear enough for an agent to know when this tool applies.

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 that this is a mutating (readOnlyHint=false) but non-destructive (destructiveHint=false) operation. The description adds useful behavioral context: it parses the HTML, converts it to a structured table representation, and supports captions and footnotes. It does not disclose potential failure modes or what happens on invalid HTML, but it goes beyond the annotations enough to avoid a lower score.

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, front-loaded with the core action, and each sentence adds distinct information. There is slight redundancy ('adds it to the specified document' echoes the first sentence), but almost no wasted words.

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 an output schema and fully documented inputs, the description covers the core operation, the transformation process, and optional features. It lacks explicit usage guidance and error-behavior notes, but the overall context signals and schema fill most gaps needed for correct selection and 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?

Schema description coverage is 100% and examples are provided for html_table, so the schema already documents each parameter thoroughly. The description adds no significant parameter-level meaning beyond repeating that captions and footnotes are optional. Baseline 3 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 states a specific verb and resource: 'Add an HTML-formatted table to an existing document in the local document cache.' It also explains the mechanism (parses HTML, converts to structured table) and this clearly distinguishes it from sibling add_title/add_paragraph/add_list_items tools. The name and description align perfectly.

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 you have an HTML table string and want to attach it to an existing cached document. However, it does not explicitly mention when not to use it, nor does it reference alternative sibling tools for adding other content types. 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 indicate this is a mutating but non-destructive operation. The description adds valuable context by specifying that the tool modifies an existing cached document and requires the document to already exist. This goes beyond the raw annotation flags and clarifies the operational precondition.

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 and well-structured, with the primary purpose stated in the first sentence and the key prerequisite clarified in the second. There is no redundant or filler content; every sentence adds relevant 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 tool with two required, fully described parameters and an output schema, this description is complete. It states what the tool does, where it operates, and the critical precondition for use. Nothing essential is missing for an agent to invoke it correctly.

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

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

The schema already provides 100% coverage for both parameters, including descriptions for 'title' and 'document_key'. The tool description doesn't add much beyond the schema, but the prerequisite about the document already existing in the cache slightly reinforces the meaning of document_key. This meets the baseline for fully documented parameters.

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

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

The description clearly states a specific verb ('add or update') and resource ('title of a document in the local document cache'), making the tool's purpose unambiguous. It also explicitly says it modifies an existing document, which distinguishes it from creation-focused siblings like create_new_docling_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 provides clear usage context: this tool is for documents already processed and stored in the local cache, and it requires the document to exist before adding a title. It does not explicitly name alternatives or state when not to use it, but the prerequisite is clear enough to avoid misuse.

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 operation. The description adds useful behavioral context by disclosing the stack cache requirement and that it closes a previously opened list structure, which helps the agent understand it is a state-changing operation.

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

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

The description is short and front-loaded, with the core action in the first sentence. The second sentence is somewhat redundant with the first, but it adds the 'previously opened' and 'stack cache' nuance, so the slight overlap is acceptable.

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 mutation tool with an output schema and annotations covering read-only/destructive hints, the description provides enough context: what it closes, where, and the required preconditions. It does not explain error handling, but that is not essential for an agent to call it correctly.

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

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

Schema description coverage is 100%, with document_key already described as the unique identifier of the document in the local cache. The description reinforces that the document must already exist, but does not add meaningful new parameter-level semantics 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 uses a specific verb ('closes') and resource ('list group in an existing document in the local document cache'), and clarifies it operates on a previously opened list structure. This clearly differentiates it from sibling tools like open_list_in_docling_document and add_list_items_to_list_in_docling_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 gives concrete preconditions: the document must exist and the stack cache must have more than one item. It implies the tool should be used after opening a list and adding items, though it does not explicitly name alternatives or state when not to use it.

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

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

Beyond the annotations, the description discloses caching behavior, the skip-if-cached rule, the boolean semantics per output, and the configured converter source (remote API or local). This is exactly the behavioral context an agent needs to predict the side effects and return values.

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 one-sentence summary is front-loaded, and the second paragraph earns its place by specifying return structure and cache behavior. There is no filler or redundant restating of the tool name.

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 single-parameter tool with an output schema, the description is largely complete: it covers the operation, storage, return shape, and caching. It does not mention how invalid or non-existent directories are handled or whether subdirectories are included, but these are secondary for correct tool selection.

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, source, is already fully described in the schema as 'The path to a local directory.' The description repeats this but adds no new format, resolution, or requirement details, so it does not improve on the schema's high 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 names a specific action—convert all files from a local directory—and a specific outcome: store resulting Docling documents in local cache. It clearly distinguishes itself from sibling convert_document_into_docling_document by operating on a directory rather than a single 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 clearly states the condition for use: the caller has a local directory path and wants every file in it converted. It implies rather than explicitly states the alternative of using convert_document_into_docling_document for a single file, so it lacks explicit when-not guidance but is not ambiguous.

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

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

The description discloses meaningful behavior beyond the annotations: conversion uses a configured converter (remote API or local), results are stored in a local cache, and conversion is skipped if the document is already cached. It also explains the boolean return semantics (False for newly converted, True for cached), which is valuable operational 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 well-structured: a one-sentence summary is front-loaded, followed by a concise paragraph explaining cache behavior and return semantics. Every sentence adds useful information without redundancy.

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

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

For a single-parameter tool with an output schema, this description is complete. It covers the conversion pipeline, caching side effect, skip behavior, and return boolean meaning. The agent has enough information to call the tool correctly and interpret its result.

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 100%, and the schema already explains the source parameter, including object-storage URI support. The description only repeats that the source may be a URL or local path without adding new parameter-level detail, so the baseline of 3 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 opens with a specific verb and resource: 'Convert a document of any type from a URL or local path and store in local cache.' This clearly distinguishes it from sibling tools like convert_directory_files_into_docling_document and create_new_docling_document by specifying single-document conversion from a URL or path.

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 establishes clear context: it is for converting a single document from a URL or local path, not a directory and not creating a blank document. It does not explicitly name alternatives or exclusion conditions, but the source scope is clear enough for an agent to select it appropriately.

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 that the document is persisted in the local document cache and that a key is derived from an MD5 hash of the prompt, both useful behavioral details beyond the annotations. The annotations already indicate a non-read-only operation, so this additional context is reasonable and does not contradict 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 two short paragraphs with the one-line summary first and the key implementation detail second. Every sentence adds value and there is 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 one-parameter creation tool with an output schema and annotations, the description covers what is created, where it is stored, and how its key is generated. It is slightly ambiguous what happens when the same prompt is submitted twice, but that minor gap does not block 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 input schema already documents the single 'prompt' parameter with 100% coverage. The description repeats that the prompt is text but adds no new constraints, formatting rules, or edge-case behavior, so it stays at the baseline for schema-covered 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 specific action ('Create') and target resource ('Docling document'), and clarifies the input is a prompt string. It also states the document is stored in the local document cache, which narrows the semantics beyond the title. It doesn't explicitly contrast with sibling converter tools, but the prompt-based creation path is sufficiently distinct.

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 text implies use when you need a new Docling document from a prompt, and 'new document' signals creation rather than conversion. However, it never explicitly says when not to use this tool or points to alternatives like convert_document_into_docling_document, so 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?

The destructiveHint annotation already signals that this operation mutates or destroys, so the description's added value is the cache prerequisite and the anchor-based scoping of what gets deleted. This provides useful behavioral context beyond the annotations and does not contradict 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 short and front-loads the operation in the first sentence. There is slight redundancy between 'Delete multiple document items identified by their anchors' and 'removes specified items ... based on their anchor references,' but it remains appropriately sized and easy to scan.

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

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

This is a simple two-parameter destructive tool with full schema coverage and an output schema. The description covers what the tool does and the important cache requirement, so an agent can safely select and invoke it. A slightly stronger description would also address invalid-anchor behavior or clarify whether deletion is irreversible.

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 coverages is 100%: document_key and document_anchors are both well-described, with examples such as '#/texts/2' and '#/tables/1'. The tool description restates the anchor-based semantics but does not add significant meaning beyond what the schema already provides, so the baseline score of 3 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 first sentence states a specific verb ('Delete') with a precise resource ('document items') and selection mechanism ('anchors'). It also clarifies that this operates on a Docling document in the local cache and can remove multiple items, making it clearly distinguishable from sibling read/update tools.

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

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

The description clearly conveys the main use case: deleting multiple cached document items by anchor references. It also states an explicit prerequisite: the document must already exist in the local cache. It does not name sibling alternatives or provide when-not-to-use guidance, but the destructive use case is obvious among the listed siblings.

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

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

The annotations already declare readOnlyHint=true and destructiveHint=false, so the safety profile is covered. The description adds that it converts a cached document into a markdown string, but does not disclose behavior around max_size truncation, error cases, or any edge conditions. 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 two concise sentences with no waste. The core action is front-loaded in the first sentence, and the second sentence clarifies the source, output format, and intended use.

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 conversion tool with two parameters, full schema coverage, and an output schema, the description is complete enough. It specifies the required precondition ('exists in the local cache'), the output type, and the purpose.

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 100%, so the schema already documents both document_key and max_size. The description reinforces the local-cache context but adds no meaning beyond the schema, so the baseline of 3 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 states a specific action ('Export'/'converts') on a specific resource ('Docling document from the local document cache') with a concrete output format ('markdown formatted string'). This clearly distinguishes it from sibling tools like save_docling_document or get_text_of_document_item_at_anchor.

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 makes the context clear: the document must already exist in the local cache before this tool can convert it, and the resulting markdown string is intended for display or further processing. It does not explicitly name alternatives or exclusions, but the usage context is well implied.

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

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

Annotations already declare readOnlyHint=true and destructiveHint=false. The description adds useful behavioral detail: it operates on the local document cache and returns line-level output containing anchor references and item labels. This is proportionate for a read-only tool and 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 compact and front-loaded with the main action and resource. The second sentence adds specific output details—hierarchy, types, anchor reference, and item label—without any filler. Every sentence earns its place.

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

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

For a single-parameter, read-only overview tool with complete input schema documentation, annotations, and an output schema, the description sufficiently covers source, behavior, and output format. Nothing essential is missing for an agent to invoke it correctly.

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

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

Schema description coverage is 100%: document_key is already described as 'The unique identifier of the document in the local cache.' The description's phrase 'from the local document cache' reinforces this but adds no additional parameter semantics beyond what the schema provides.

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 'Retrieve a structured overview of a document from the local document cache' and then explains that the output is a text representation of the document's hierarchy and element types, with each line containing an anchor reference and item label. This clearly identifies the action, resource, and output, and differentiates it from sibling content-retrieval or mutation tools.

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

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

The usage context is implied: use this when you need a structural overview of a cached Docling document. However, there is no explicit statement of when to prefer this tool over alternatives such as search_for_text_in_document_anchors or get_text_of_document_item_at_anchor, and no 'when not to use' 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=true and destructiveHint=false, so the safety profile is covered. The description adds meaningful context by specifying that the document must exist in the local document cache and that extraction is targeted at an anchor location, which helps the agent understand prerequisites.

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 short and front-loaded with the core purpose in the first sentence. The second sentence repeats some of the same information, but it adds useful cache context, so the slight redundancy is acceptable.

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 a full input schema, output schema, and safety annotations, the description is largely complete. It covers the key prerequisite of cache residency, though it does not explain behavior for invalid or missing anchors; that 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 100%, with both document_key and document_anchor already described clearly, including an example anchor format. The tool description adds no parameter-level meaning beyond what the schema provides, so the baseline score of 3 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 ('Retrieve'/'extracts') and names the precise resource: text content of a Docling document item at an anchor. It stands apart from siblings like update_text_of_document_item_at_anchor and search_for_text_in_document_anchors by clearly focusing on read-only text 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?

The description implies when to use the tool: after a document exists in the local document cache and when you need the text of a single anchored item. However, it gives no explicit guidance about alternatives or when not to use it, such as when needing to search anchors or update text.

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 the local-cache/convertion context but does not disclose return details or failure behavior; with an output schema present, that gap is acceptable but still minimal 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 one clear sentence with no filler, and the core predicate and resource are front-loaded. Every word contributes to understanding the tool's purpose.

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

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

For a simple single-parameter, read-only predicate with a documented input schema and an output schema, the description is sufficient. No return value explanation is needed because the output schema exists, and the tool's narrow scope is fully represented.

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

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

The single parameter document_key is fully documented in the schema with 100% coverage. The description adds no additional semantic meaning about the parameter, so the schema carries the burden and the baseline of 3 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 states a specific verb ('Verify if') and resource ('Docling document ... in local cache'), clearly identifying this as a cache-lookup predicate. This distinguishes it from the conversion, saving, and modification sibling tools without needing to inspect them.

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 'already converted' implies this tool is useful for checking before doing conversion work, but the description never explicitly says when to use it versus alternatives or when not to use it. No sibling tool is named or compared.

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 mutating but non-destructive operation. The description adds useful preconditions about the document being cached and the stack cache having content, but it does not clarify the stateful nature of opening a list group or what the agent should expect afterward.

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 reasonably concise and front-loads the core purpose. There is minor redundancy between 'Open a new list group' and 'creates a new list structure,' but overall the wording is efficient.

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

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

For a one-parameter tool with annotations and an output schema present, the description covers the essential precondition and core behavior. It could mention subsequent list-item operations, but this is not required 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?

Schema coverage is 100% and the single document_key parameter is already described. The description adds context about the document needing to exist in the local cache but does not materially extend the parameter-level meaning.

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

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

The description clearly states a specific action: opening/creating a new list group within an existing cached document. It is distinct from siblings like close_list or add_list_items, though it does not explicitly name them.

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 prerequisites are clear: the document must exist and the stack cache must have at least one item. However, the description does not explain when to choose this tool over related list operations, such as add_list_items_to_list_in_docling_document, so usage context is only implied.

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 the local-cache precondition, which is useful, but doesn't disclose what happens if the document is missing, how the image is returned, or any other behavioral details beyond the annotation coverage.

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 short and front-loaded, but it is redundant: 'generates a thumbnail image for the requested page' appears in both sentences. The second sentence does add the local-cache precondition, but it repeats the main action unnecessarily.

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

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

The tool is simple, has complete schema documentation, and has read-only annotations, so the core requirements are covered. However, there is no output schema, and the description does not clarify what the tool returns or how the generated thumbnail is delivered, which is a notable 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 100%, so all three parameters (document_key, page_no, size) are already documented in the schema. The description does not add additional semantics or examples beyond what the schema provides, so the baseline 3 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 clearly states the action ('generates a thumbnail image'), the target ('the requested page'), and the key constraint that the document already exists in the local cache. This distinguishes the tool from other document manipulation and cache-related siblings.

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 clearly conveys the prerequisite that the document must already be in the local cache, which is essential context for when the tool can be used. It does not explicitly name alternatives or exclusion conditions, but the context is strong enough for an agent to understand the required state.

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 that both markdown and JSON files are written and that filenames depend on the document key, which goes beyond the annotations. It does not disclose whether existing files are overwritten or what happens if the document is not in the cache; this is a moderate transparency gap, but there is no annotation contradiction.

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 main purpose is front-loaded in the first sentence, and the second sentence adds necessary operational detail without redundancy. Every sentence earns its place.

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

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

For a single-parameter tool with an output schema and annotation coverage, the description is largely sufficient: it states the precondition, the action, and the output forms. The missing overwrite/collision behavior is a minor gap but does not prevent 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 input schema fully documents document_key as the unique identifier, so the baseline is 3. The description adds meaningful context by explaining that the document key is used not only for cache lookup but also for deriving the output filenames.

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 ('Save'), a specific resource ('document from the local document cache'), and the exact output formats ('both markdown and JSON'). This clearly distinguishes it from sibling tools like export_docling_document_to_markdown or conversion tools.

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

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

It clearly conveys that the tool operates only on documents already present in the local cache, which is a useful precondition. However, it does not explicitly mention alternatives or conditions for choosing this tool over sibling export tools, so it falls just 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?

The description goes well beyond the readOnlyHint/destructiveHint annotations by explaining the exact search behavior: case-insensitive matching, fallback to splitting the input into keywords on non-alphanumeric characters, and reporting keyword occurrence counts. This gives an agent a clear model of what will happen.

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 and well-structured, opening with the core purpose and then elaborating with necessary behavioral details. Each sentence adds useful information, with no redundant or filler content.

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

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

Given the presence of an output schema, the description does not need to detail return values. It covers the main functionality, search behavior, and fallback logic. A possible gap is the absence of a stated behavior when neither the exact text nor any keywords are found, but 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 coverage is 100%, with both parameters described in the input schema. The description adds context about the search behavior but does not add new semantic detail about the parameters themselves, so a baseline of 3 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 clearly identifies the operation as searching for text within a document's anchors, using a specific verb and resource. It distinguishes the tool from siblings that retrieve or modify anchors, 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?

The description implies when to use the tool: to find document anchors containing a specific text or keywords. However, it provides no explicit guidance on when to prefer this over related tools like get_overview_of_document_anchors or get_text_of_document_item_at_anchor.

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 this as mutating and destructive, so the description does not need to repeat that. It adds useful behavioral context by explaining the target must be an existing document item and that the document must already be cached, which goes beyond the raw 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 concise, consisting of two short sentences that convey the primary action and the key prerequisite. It is front-loaded with the core purpose and contains no filler or redundant 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?

With full schema coverage, an output schema, and annotations indicating destructive behavior, the description covers the essential operational context: the update targets an existing cached item by anchor. It could add a note about how to obtain valid anchors or the need to save after updating, but these are not critical gaps given the sibling tools and existing schema.

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 100%, so the schema already fully documents all three parameters: document_key, updated_text, and document_anchor. The description does not add parameter-level details beyond what the schema provides, so a baseline score of 3 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 ('Update') and resource ('text content of a specific document item identified by its anchor'), making the tool's function immediately clear. It also distinguishes this from sibling tools like get_text_of_document_item_at_anchor and delete_document_items_at_anchors by focusing on modifying existing text.

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 clearly states that the tool requires the document to already exist in the local cache before modification, providing meaningful context for when it can be used. It does not explicitly mention alternatives or when not to use it, but the prerequisite is clear enough to guide the agent.

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