Claix

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

Annotations already declare readOnly/openWorld/idempotent/non-destructive; the description adds supported formats, the is_agent_mode prerequisite, and return fields. It enriches rather than repeats structured data and does not contradict annotations.

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

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

One concise sentence front-loads purpose, formats, prerequisite, and return fields. Every phrase earns its place with no 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?

With rich schema, annotations, and output schema, the description is sufficient for tool selection; it states formats and prerequisite. It does not clarify what 'is_agent_mode' is or how to supply input, but those are mostly covered by 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 covers all 5 parameters with detailed descriptions, so baseline is 3. The description adds no parameter-level detail and introduces 'is_agent_mode' which is not present in the schema, potentially causing confusion, but actual parameters are well documented.

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 uses specific verb 'Run' and identifies resource ('document extraction plus Agent mode reasoning') with supported .docx/.txt/.md/.rtf formats. It clearly distinguishes from sibling claix.extract.doc by adding 'Agent mode reasoning' and the resulting agent_data.

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?

States explicit prerequisite 'Requires is_agent_mode', giving clear context for when this should be used. Does not explicitly name claix.extract.doc as the plain-extraction alternative, so it lacks full when-not/alternatives 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, idempotentHint=true, and destructiveHint=false, so the safety profile is covered. The description adds useful behavioral context beyond annotations by specifying a schema prerequisite ('Requires is_agent_mode on the schema') and outlining the return structure ('data[] and agent_data with typed answers'). 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 two concise sentences. The first sentence front-loads the main purpose, and the second adds a prerequisite and output summary. Every word earns its place with no redundancy or 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 description covers the core purpose, a key prerequisite, and the main return fields, while output schema and annotations fill in details. It does not elaborate on what 'semantic reasoning' entails or how file inputs are selected, but those are either covered in the schema or not essential for invoking the tool correctly.

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

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

All 5 parameters have detailed descriptions in the input schema (100% coverage), so the schema carries the parameter documentation burden. The description does not add parameter-specific meaning; it only references a schema configuration flag ('is_agent_mode') that is not among the tool's own parameters. 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 tool runs 'Excel/CSV extraction plus Agent mode semantic reasoning', naming the resource and adding a specific capability that distinguishes it from claix.extract.excel and sibling agent tools. The mention of returning 'agent_data with typed answers' further differentiates it from simple 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 use for semantic reasoning over Excel/CSV via 'Agent mode semantic reasoning' and names a prerequisite ('Requires is_agent_mode on the schema'). However, it does not explicitly state when not to use it or compare directly with alternative extract tools, so it stops short of full exclusion 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, idempotentHint, and destructiveHint:false, so the safety profile is covered. The description adds return shape (data[] and agent_data) and the 'visible content' scope, but the unexplained 'Requires is_agent_mode' creates ambiguity about preconditions.

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

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

The description is two short sentences, front-loaded with the action and output, with no filler. It is concise 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?

Despite having a rich schema and output schema, the description leaves 'Agent mode' undefined and the is_agent_mode requirement unaddressable. It also does not clarify how the image should be provided or when to use this vs. the extraction-only siblings. The tool has 5 parameters and multiple input methods, so more context is needed.

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 a baseline of 3 is appropriate. However, the description introduces 'is_agent_mode' as a requirement even though no such parameter exists in the schema, actively confusing parameter handling. It adds no useful parameter-level meaning beyond the schema.

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

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

The description uses a specific verb ('Run') and names the resource ('image extraction plus Agent mode reasoning'), and the title clarifies the JSON output. It differentiates from claix.extract.image by adding Agent-mode reasoning. However, 'Agent mode' is unexplained jargon, so it is not fully self-contained.

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 choose this over siblings like claix.extract.image or claix.agent.pdf. The 'Requires is_agent_mode' line states a requirement but provides no context, and no alternatives or exclusions are mentioned.

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 as read-only and idempotent. The description adds meaningful behavioral context beyond annotations: it explains that extraction is coupled with agent reasoning and describes the nature of returned agent_data, which is not evident from annotations alone. No contradictions found.

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 (two sentences) and front-loaded with the core purpose. The second sentence adds prerequisite and output info without unnecessary fluff. Slight ambiguity around 'Requires is_agent_mode' (as it is not a schema parameter) prevents a perfect score.

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 appropriately focuses on purpose and behavior rather than return format. It explains the nature of agent_data and the prerequisite, which is sufficient for understanding the tool within its sibling group. Could be more complete by explicitly stating file input methods, but these are already in the 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?

The input schema already provides 100% parameter descriptions, so baseline is 3. The description mentions 'Requires is_agent_mode' and references schema-defined rules, but does not add syntax or formats beyond what the schema covers. It neither enhances nor complicates parameter understanding.

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 ('Run') and resource ('PDF extraction') plus a differentiating feature ('Agent mode reasoning'). It clearly distinguishes this from claix.extract.pdf by mentioning agent-based processing, and the mention of 'structured data[] and agent_data' clarifies the output scope.

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

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

The description provides a clear precondition ('Requires is_agent_mode') and outlines the type of output ('business rules, booleans, or summaries defined in the schema'), which implies use cases. It does not explicitly name alternatives like claix.extract.pdf for simpler extraction, but the context of sibling tools makes the intended usage reasonably clear.

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?

While annotations already indicate read-only and idempotent behavior, the description adds information about required is_agent_mode and the output type (data[] and agent_data), offering additional transparency beyond the annotations without 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 description is concise, containing multiple short sentences that convey the key points: what it does, requirements, output, and endpoint. It is well-structured and to the point, though slightly repetitive in mentioning 'agent mode' multiple times.

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 provides a minimal overview of inputs and outputs but lacks details on the exact structure of the returned data or specific use cases. Given the simplicity of the tool and presence of annotations, it is adequate but not fully complete.

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 descriptions cover all three parameters comprehensively, so the baseline is 3. The description does not add extra meaning beyond the schema, but the schema is sufficient.

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 it performs text/HTML/XML extraction and agent mode reasoning, which is somewhat specific but does not clearly distinguish from sibling extraction tools like extract.text or convert.json_to_excel. The purpose is understandable but could be more precise.

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 guidance is provided on when to use this tool versus alternatives. It simply describes the action without mentioning conditions or preferences for selecting it over similar tools.

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

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

Annotations already cover safety (readOnly, idempotent, non-destructive). The description adds behavioral context: it requires a schema_id (dependency) and returns base64-encoded xlsx. It also clarifies the file_base64 input should be a .json file, which the schema description ambiguously refers to as PDF/image. 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?

Three concise sentences: purpose, input method, and return format. Front-loaded with the primary action, no fluff 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 6-param tool with an output schema, the description covers the core workflow (convert JSON to Excel), input options, and output. It doesn't explain the schema concept in depth, but that is referenced and the schema_id is documented in the schema. Given output schema exists, return values are sufficiently covered.

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%, giving a baseline of 3. The description adds meaning by explicitly stating json_data and file_base64 are alternative inputs ('or'), and clarifies that file_base64 should be a .json file, which is not clear from the schema description. This goes 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 clearly states the tool converts JSON to an Excel .xlsx file using a Claix schema, with a specific verb and resource. It distinguishes from sibling extract/agent tools by focusing on JSON-to-Excel conversion.

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 clear context on how to use the tool (provide json_data inline or file_base64 with a .json file) and the return format. It doesn't explicitly name alternatives or when-not-to-use, but the use case is unambiguous given sibling tools are extract/agent tools.

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

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

Beyond the annotations, the description adds 'Irreversible,' 'Free call,' the success response shape, and specific 404 conditions, all of which materially inform an agent's decision to invoke this destructive tool. It fully aligns with the destructiveHint and idempotentHint 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?

Every sentence in the description earns its place: the operation, the HTTP route, parameter constraints, success response, irreversibility, cost, and error semantics. It is compact, front-loaded, and free of 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 two-parameter destructive tool, the description covers invocation, success behavior, failure conditions, cost, and side effects. The output schema and parameter descriptions in the input schema cover the remaining structured details, making this definition effectively complete.

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 has 100% description coverage, so the baseline is 3. The description adds extra semantic value by clarifying that document_id is a path parameter and that no body or query parameters are accepted, which is not evident from the schema alone.

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

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

The description states a specific verb and resource: 'Delete a persisted document by document_id,' and reinforces it with the exact HTTP path (DELETE /delete-document/{document_id}). This clearly distinguishes the tool from siblings like claix.schemas.delete by targeting persisted documents rather than schemas.

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

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

The intended use is clear: delete a persisted document when its document_id is known. It does not explicitly name alternatives or exclusions, but it provides strong operational guidance by stating there are no body/query parameters and by explaining the 404 behavior for missing, foreign, or already-purged documents.

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

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

Annotations already declare readOnlyHint, idempotentHint, and non-destructive behavior. The description adds valuable constraints not present in the annotations, such as the 10 MB file size limit and the unsupported .doc format, which go beyond the structured fields.

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 efficient sentence that front-loads the purpose and lists key constraints (formats, max size, unsupported .doc). Every word earns its place, with no redundant 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 rich annotations, output schema, and comprehensive parameter descriptions, the tool description provides the critical extra constraints (file formats, size cap, .doc exclusion) needed for correct usage. It doesn't describe the return format, but the output schema covers that.

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 detailed, example-rich parameter descriptions, including cross-references like calling claix.schemas.list. The tool description adds no per-parameter semantics but reinforces the overall schema-based workflow; 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 tool extracts structured JSON from Word documents, specifying supported formats (.docx, .txt, .md, .rtf) and a size limit. It is distinguished from sibling extraction tools (pdf, excel, image) by format and file type.

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 lists supported formats and explicitly excludes legacy .doc, providing clear when-to-use guidance. It does not explicitly name alternative tools for other document types, but the format list implies the appropriate use case.

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 provide readOnlyHint, idempotentHint, and destructiveHint=false. The description adds valuable behavior not in annotations: 'Processes the first sheet only' and 'Returns typed JSON matching the schema.' This goes beyond what annotations disclose without any 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?

Three concise sentences, front-loaded with the core action. Every sentence adds value: what it does, a key behavioral caveat, and when to use it. 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?

Given the rich input schema (100% coverage), comprehensive annotations, and output schema, the description covers essential context: file types, first-sheet behavior, return type, and usage scenario. Nothing critical 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 100%, and each parameter (schema_id, filename, file_path, file_base64, api_key) has a detailed description. The tool description itself does not add parameter details, so baseline 3 is appropriate per the rubric.

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

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

The description clearly states the tool extracts structured JSON from Excel/CSV files using a schema, with a specific verb and resource. It distinguishes from sibling tools like claix.extract.pdf and claix.extract.image by explicitly mentioning spreadsheet/CSV input.

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 clear usage context: 'Use when the user attaches a spreadsheet or CSV.' It does not explicitly name alternative tools or exclusions, but the sibling list implies the differentiation. This is clear enough but not as explicit as naming alternatives.

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

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

Annotations already declare readOnlyHint, idempotentHint, and destructiveHint=false, so the safety profile is covered. The description adds useful behavioral details like supported image formats and the 15 MB size limit, but it does not disclose failure modes, auth requirements beyond the api_key parameter, or any other 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 compact, two sentences, and front-loaded with the primary action and key constraints. Every sentence adds value: the first states purpose and input restrictions, the second gives concrete use cases. No redundancy or 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?

With a full input schema, rich annotations, and an output schema present, the description covers all necessary context: supported formats, size limit, and target use cases. It is complete for an extraction tool of this scope, leaving no major gaps for an agent to infer.

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 100% description coverage, with each parameter already thoroughly documented (e.g., schema_id format, file_path must be HTTPS, file_base64 accepts data URLs). The description adds minimal parameter-level value beyond mentioning it uses a 'Claix img-json schema,' which hints at the schema type, but does not compensate further since the schema handles semantics.

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

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

The description clearly states the tool extracts structured JSON from images, with a specific verb ('Extract') and resource ('visible image'). It also enumerates supported formats and size limits, and distinguishes itself from sibling extract tools by focusing on image inputs.

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

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

The description explicitly states 'Use for photos of documents, tickets, or labels,' which provides clear context for when to apply the tool. However, it does not explicitly name alternative tools (e.g., claix.extract.pdf) or state when not to use it, though sibling names imply those alternatives.

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

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

Annotations already declare readOnlyHint, idempotentHint, and non-destructive behavior. The description adds valuable context beyond this: file size limit (15 MB), support for scanned PDFs (OCR), and the exact output location (data[]). No contradictions. This is a good but not exhaustive disclosure (e.g., no rate limits or output schema explanation).

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 tight sentences with no filler. The first sentence front-loads the verb, resource, and key constraints; the second sentence provides use cases. Every word earns its place.

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

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

For a medium-complexity tool, the description covers the essential purpose, output format, size limits, and input type. An output schema exists and annotations are present, so the description need not explain return values or safety. A minor gap: the need to create/clarify a schema beforehand is only in the parameter description, not the main description, but it is still discoverable.

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 100% description coverage, so the baseline is 3. The main description does not add much parameter-level detail; it mentions 'using a Claix pdf-json schema' which relates to schema_id, but the schema descriptions already explain all five parameters clearly. No need for extra compensation.

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

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

The description uses a specific verb ('Extract') and identifies the resource ('PDF') and output ('structured JSON'), with a clear scope ('text or scanned, max 15 MB'). It also names the schema type ('Claix pdf-json') and output shape ('single JSON object in data[]'), which differentiates it from sibling extract tools for doc/excel/image.

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 use cases ('invoices, contracts, forms, or reports') that indicate when to apply this tool. It does not explicitly mention alternatives or exclusions, but the sibling tool names (e.g., claix.extract.doc) make the differentiation implicit. This meets 'clear context, no 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, idempotentHint, and non-destructive behavior. The description adds useful behavioral constraints beyond those: max 300,000 characters, no file upload, and the requirement that input must already be processed. 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 short, front-loaded with purpose, and includes only a few supporting details. The phrase 'POST /api/txt-json' is arguably redundant for MCP invocation, but it is minor and does not significantly hurt clarity.

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 rich input schema, output schema, and annotations, the description is sufficiently complete. It covers input type, payload mechanism, size limit, and schema usage. Return values are already documented by the output schema, so no additional explanation is needed.

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

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

Schema descriptions cover all parameters (100%), so the baseline is 3. The description adds value by specifying the content field as the payload location, emphasizing 'no file', and introducing the 300,000-character limit, which is not present in the schema. This supplements the parameter meaning beyond the schema alone.

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

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

The description states a specific action ('Extract structured JSON') and resource ('already processed plain text, HTML, or XML'), and clarifies the output format. It also distinguishes itself from sibling extract tools by explicitly noting 'no file' and 'already processed', making its scope 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 gives clear usage context: use it for already processed text/HTML/XML, send payload in content, and respect the 300,000-character limit. It does not explicitly name alternative tools or state when not to use it, but the 'no file' and 'already processed' cues strongly imply the boundary versus file-based extract tools.

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

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

Annotations already indicate the operation is not read-only and not idempotent; the description adds the POST endpoint and creation intent. It does not disclose side effects, persistence behavior, or other operational details beyond what annotations and schema already show.

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 communicates action, endpoint, required fields, accepted type values, and optional fields. There is no filler or 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?

Given the rich input schema, output schema, and annotations, the description is sufficient for a straightforward create operation. It could mention how the schema relates to extraction/agent tools, but that is not necessary to invoke the endpoint 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%, so the schema already documents all parameters. The description summarizes required and optional fields but does not add meaning beyond the schema's own per-parameter descriptions.

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

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

The description clearly identifies the action ('Create') and resource ('Claix schema') and includes the explicit HTTP endpoint. The create operation is distinct from sibling tools such as claix.schemas.delete and claix.schemas.list.

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

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

No guidance is provided on when to use this tool versus alternatives, nor are prerequisites or workflow context described. The parameter list is useful but does not help an agent decide when creating a schema is appropriate.

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 destructiveHint=true and readOnlyHint=false, so the description need not repeat safety. However, description adds context about ownership and the specific endpoint. It does not disclose side effects (e.g., permanence, dependent resources) beyond what 'delete' implies. Since annotations cover the destructive nature, the description adds modest value.

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

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

The description is two short sentences. The first sentence immediately states the action, object, and endpoint; the second highlights the required parameter. No filler or redundancy. Every word serves a 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?

Given the tool's simplicity (delete a schema by ID), the description is complete enough: it defines the operation, the scope, and the requirement. An output schema exists, so no need to explain return values. Slight omission: does not explicitly state that deletion is permanent, but destructiveHint true covers that. Overall adequate for a straightforward delete tool.

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

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

The input schema provides 100% coverage for both parameters, including detailed descriptions and examples. The description only mentions 'schema_id' as required, which adds no new semantic meaning beyond the schema. With high schema coverage, the description is adequate but not enriched.

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: 'Delete a Claix schema'. It specifies the HTTP method and endpoint (POST /api/delete-schema) and scopes the deletion to schemas 'owned by the API key'. This unambiguously distinguishes it from siblings like claix.schemas.create and claix.schemas.list.

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 indicates a prerequisite ('Requires schema_id') but does not explicitly state when to use this tool versus alternatives or when not to use it. It does not mention looking up schemas first (though the schema parameter description does). Minimal guidance beyond the requirement.

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

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

Annotations already declare readOnlyHint, idempotentHint, and non-destructive behavior, so the safety profile is well covered. The description adds context by mentioning the authenticated account and enumerating the exact return fields (id, name, type, etc.), which goes beyond the annotations.

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

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

The description is two sentences, front-loaded with the primary action and return fields, followed by the usage instruction. Every sentence adds value with no redundancy or 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 simple list tool with an output schema and strong annotations, the description is complete. It states the resource, authentication context, return fields, and when to call it, leaving no significant gaps for an agent to select and 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 input schema has 100% description coverage for the single api_key parameter, so the baseline is 3. The tool description does not add any parameter-specific meaning beyond what the schema already provides, but it doesn't need to given the schema's completeness.

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

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

The description clearly states the tool's function: 'List the Claix schemas available for the authenticated account.' It specifies the verb and resource, lists the returned fields, and explicitly positions itself as a prerequisite for claix.extract.* and claix.agent.* tools, distinguishing it from 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 provides explicit usage guidance: 'Call this first whenever you need a schema_id before claix.extract.* or claix.agent.* tools.' This tells the agent when to use this tool relative to its siblings and establishes a clear workflow.

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?

While annotations already declare read-only, idempotent, open-world, and non-destructive behavior, the description adds worthwhile behavioral specifics: it returns 'user_ask and ia_response', including that ia_response is null if the answer is not in the document. It also exposes the POST endpoint. This goes beyond the annotations without contradicting them.

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

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

The description is three sentences and every sentence contributes meaningful information: what the tool does, the prerequisite, the size limits, and the return value structure. No filler or redundancy. It is front-loaded with the main 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?

Given the low complexity (3 parameters, simple array input) and rich annotations plus an output schema, the description covers the essential behavioral contract: usage prerequisite, question limits, response fields, and null result meaning. The tool is simple enough that this is a complete description.

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%: the schema already documents api_key with an example, document_id as a UUID with a concrete example, and questions with array constraints and an example. The description only repeats the 400-character and 5-question limits already present in the schema, so it adds little new parameter 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 opens with a specific action verb and resource: 'Ask up to 5 questions about a persisted document', and identifies the exact HTTP endpoint. It clearly distinguishes this from sibling extraction and document-creation tools by specifying the Q&A-over-persisted-document use case.

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 states an explicit prerequisite: 'Requires document_id from an extraction with window_context'. It also constrains usage with the 5-question limit and the 400-character per-question rule. It does not explicitly contrast with alternatives, but no sibling tool performs the same persisted-document Q&A function, so usage context is adequate.

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, openWorldHint, idempotentHint, and destructiveHint=false, so the safe-read nature is covered. The description adds the GET endpoint, persisted-document scope, and 'Free call' note, but it does not describe rate limits, auth-failure behavior, or other side effects. This adds some value but not rich behavioral 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?

Three short sentences front-load the core action and endpoint, then provide prerequisites, return fields, and cost. There is no filler or redundant repetition of schema details.

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-required-parameter GET tool, the description combined with full schema coverage, rich annotations, and an output schema is sufficient. An agent knows what it retrieves, where the ID comes from, what it returns, and that the call is safe and free.

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 both parameters with descriptions and an example, and it already states that document_id comes from a window_context extraction. The description therefore adds no new parameter meaning beyond what the schema provides; with 100% schema coverage, 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 names a specific verb ('Retrieve'), a concrete resource ('persisted document'), and an endpoint ('GET /window-context/{document_id}'), and lists the exact return fields. This clearly distinguishes it from extract.* siblings and from claix.window_context.ask.

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 precondition: document_id must come from an extraction with window_context, and it notes the call is free. It does not explicitly name alternatives or state when not to use it, but the context is clear enough for an agent to decide.

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