Brainiall Image

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

Annotations already indicate read-only, idempotent, non-destructive behavior. The description adds useful return contract details (status, models, version), which helps an agent understand what the tool will report. No side effects or edge behaviors are hidden, and there is no contradiction with annotations.

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

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

The description is compact and front-loaded with the core purpose, followed by a structured return summary. Every sentence contributes useful information, and the formatting makes the return keys easy to parse.

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

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

For a zero-parameter health-check tool with rich annotations, the description is complete. It specifies the operation, the returned fields, and their general meaning, which compensates for the lack of an output schema. No critical calling information 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?

The tool has zero parameters, so the baseline of 4 applies. The description correctly focuses on behavior and return values rather than inventing parameter documentation. There is nothing further an agent needs to know about inputs.

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

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

States a specific verb ('Check'), a clear object ('health status of Image API services and loaded models'), and distinguishes itself from the sibling tools, which are all content-processing operations rather than service inspections. The intent is unmistakable.

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 communicates a clear use context: this is a health-check tool for image services and models, so an agent can infer it should be used to verify readiness or diagnose service state. It does not explicitly name alternatives, but no sibling tool offers a health-check function, so no exclusion is necessary.

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

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

Annotations already mark the tool as readOnly, idempotent, and non-destructive. The description adds meaningful behavior beyond this: blank pages return an error rather than a guess, and the return structure is disclosed with fields null when absent. This is solid transparency, though it omits details like rate limits or authentication requirements.

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, followed by a key error behavior and a clear return structure. Every sentence earns its place, and there is no filler.

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

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

Since there is no output schema, the description correctly and sufficiently documents the return keys and null behavior. It also covers the main error case. It is nearly complete for a low-complexity read-only tool, though it could better route agents away from sibling document tools.

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 adds that doc_type selects the field schema, which clarifies its role. However, the description lists only six doc_type options while the schema lists additional valid types such as business_card, w2, and pay_stub, which could mislead an agent relying solely on the description.

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: turning a document image into structured fields, with doc_type selecting the schema. It is specific about the resource and output, though it does not explicitly differentiate it from sibling tools like document_to_markdown or document_tables.

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 the tool should be used: when structured field extraction from a document image is needed. It also gives a useful error condition for unreadable pages. However, it does not explicitly state when to prefer this over document_query, document_tables, or document_to_markdown, nor provide 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 establish read-only/idempotent behavior. The description adds meaningful behavioral context beyond those hints: it explains that the tool returns found:false rather than guessing, and documents the exact return keys and nullability. This helps the agent understand failure behavior.

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

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

The description is concise and well-structured: purpose first, then key behavioral guarantee, then return shape. Every sentence contributes information, and the return list is necessary because there is no output schema.

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, read-only tool, the description covers inputs, behavior, and return structure well. The main gap is the undocumented 'text' field in the return dict, and there is no mention of failure modes beyond the found:false case.

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 both parameters are already documented in the schema. The description mirrors that information without adding extra constraints, formats, or usage details 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 uses a specific verb and resource: 'Ask a natural-language question about a document image.' It clearly states the output ('a grounded answer plus the supporting line') and includes the no-guessing fallback, which makes it distinct from sibling extraction/markdown/image 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 use case is implied by the tool name and description, but there is no explicit guidance about when to use this tool instead of siblings like document_extract or understand_content, nor any exclusion criteria. The description tells what it does, not when to prefer 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?

Annotations already mark the operation read-only/idempotent, and the description adds useful behavioral detail: the exact return keys (table_count, tables), table objects (title, headers, rows, row_count, column_count), and the explicit empty-list behavior for documents without tables. It stops short of mentioning failure modes or OCR limitations.

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 compact sentences plus a structured Returns list. The purpose is front-loaded and every sentence contributes: first defines operation, second defines return contract. No filler.

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

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

Given there is no output schema, the description compensates by defining the return dict and the no-table case. It also benefits from annotations covering read-only and idempotency. A minor gap is the absence of error/limitation notes, but the tool is simple enough that the essential contract is present.

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 the image parameter thoroughly described as 'Base64-encoded PNG/JPEG of the document page.' The description only reinforces that the input is a document image, adding no new 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 the specific verb 'Reconstruct' with the resource 'every table in a document image' and spells out the deliverable 'headers and rows,' which clearly distinguishes this from sibling extraction tools like document_extract or document_to_markdown by focusing on tabular structure.

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 states the context: use on document images when you need table structure ('every table ... into headers and rows'). It doesn't explicitly discuss when not to use it or name alternatives, but the single-purpose scope and siblings make the use case apparent.

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 safety profile is covered. The description adds only 'Brainiall Doc Layout engine' and 'LLM-friendly format,' which is marginal behavioral context. There is no contradiction with the annotations.

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

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

The first sentence is direct and informative, front-loading the core behavior and output format. The second sentence is short but largely branding-oriented; it adds mild context about LLM suitability but could be tighter. Overall the description is concise and well structured.

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?

Combined with the schema and annotations, the description gives the agent enough to understand the input (base64 PDF), optional page range, and output (structured Markdown). It lacks explicit routing among sibling tools and any note on limits or errors, but for a simple read-only conversion tool it is nearly 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?

Schema description coverage is 100%, so the input schema already explains the base64 PDF and page_range parameters. The description does not add parameter-level semantics, but with full 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 uses a clear verb ('Return') and resource ('the document') and specifies the exact output format: structured Markdown with headings, tables, lists, code blocks, and math. However, it does not explicitly differentiate this tool from sibling document tools like document_extract or document_tables, and the claim 'single API' is undercut by the existence of those 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 gives no concrete guidance on when to use this tool versus alternatives such as document_extract, document_tables, or document_query. 'The single API for converting documents to LLM-friendly format' is an assertion rather than usable routing guidance, and there are no exclusions or conditions stated.

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

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

Annotations already mark this as read-only, idempotent, and non-destructive; the description adds useful behavioral context by disclosing the Brainiall Cutout engine, the transparent/white background behavior per format, and sub-500ms GPU latency. It does not cover failure modes or rate limits, but annotation coverage lowers the burden.

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

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

The description is well-organized: a clear purpose statement, optional context, then structured Args and Returns sections. The latency note is the only non-essential detail, but it does not bloat the entry.

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

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

With no output schema, the Returns block fully documents the result keys and types, which an agent needs to consume the output. Input formats, output format choices, defaults, and background color behavior are all specified, making the tool safely callable.

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 Args section mostly repeats the schema's parameter descriptions. It does add the default output format in prose, but this is already present in the schema, so the description provides no substantial 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 first sentence names the exact verb and resource: 'Remove the background from an image.' It also names the segmentation engine, which clearly differentiates it from sibling image tools like upscale_image and restore_face without needing to open 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 description makes the intended use clear by stating the operation and the supported input formats. It does not explicitly contrast with alternative tools or list exclusions, but the sibling set contains no overlapping background-removal tool, so the omission is minor.

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

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

Annotations already indicate readOnly, openWorld, idempotent, and non-destructive behavior. The description adds meaningful behavioral context beyond that: RetinaFace face detection, restoration of blur/noise/compression artifacts, compositing faces back, optional background enhancement, and GPU-accelerated sub-3s latency. This gives the agent a clear model of what happens at runtime.

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 with an overview, Args, and Returns sections. It is information-dense but not bloated; every section earns its place, and the Returns section is especially justified because no output schema exists.

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 fully covers a tool with no output schema: it explains the operation, parameters, defaults, and complete return format. It covers performance, optional background behavior, and the required input, making it sufficient for an agent to invoke the tool correctly.

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

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

Schema description coverage is 100%, so the baseline is 3. The description adds a bit beyond the schema by listing supported image formats (PNG, JPEG, WebP) for image_base64 and restating defaults. This small extra semantic detail helps the agent prepare the input correctly.

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: 'Restore and enhance faces in an image with the Brainiall face-restoration engine.' It adds process details like RetinaFace detection and pasting faces back, which clearly distinguishes this tool from siblings like remove_background or upscale_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?

Usage is implied rather than explicit: the description explains that the tool is for face restoration and optional background enhancement, so an agent can infer when to use it. However, it does not explicitly state when not to use it or mention sibling alternatives such as upscale_image.

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

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

Annotations already establish readOnlyHint, idempotentHint, and destructiveHint=false, so the safety profile is covered. The description adds meaningful behavioral context: it acts on 'a document image or text', runs multiple skills, and 'Returns per-skill outputs ready for indexing or RAG' in one call. No surprising side effects or limits are disclosed, but none are indicated and the added context 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 compact: the core action and result are front-loaded in the first sentence, and the return behavior is in the final sentence. The standalone fragment 'Brainiall Skillsets engine.' is essentially brand filler that adds little beyond the tool name, but the rest of the text is efficient and to the point.

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 complexity of a multi-skill pipeline and the absence of an output schema, the description covers the main purpose and broad result, with schema and annotations filling safety and parameter details. However, it does not route the agent among the many sibling document tools, and it does not explain what happens when skills is null (e.g., all skills applied?) or when both text and image are provided. These are clear gaps.

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

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

Schema description coverage is 100%: text ('Pre-extracted text (skip OCR)'), image ('Base64 image (triggers OCR)'), and skills ('Enrichment skills: ocr | entities | language | keyphrases | sentiment') are already documented. The tool description itself adds no new parameter details, so the schema does the heavy lifting and the baseline 3 applies. No formal enums are present, but the skills description enumerates valid values.

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 explicitly states 'Run a multi-skill enrichment pipeline over a document image or text in one call' and notes it 'Returns per-skill outputs ready for indexing or RAG,' providing a specific verb, resource, and expected outcome. It is distinguishable from siblings like document_extract or document_tables by emphasizing multi-skill enrichment in a single call, though it does not name those 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 phrases 'in one call' and 'multi-skill enrichment' imply this is for running several enrichment skills at once, and 'ready for indexing or RAG' hints at downstream use. However, the description never explicitly states when to choose this tool over document_extract, understand_content, or document_to_markdown, and it offers no when-not-to-use guidance or alternative routing.

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

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

Annotations already convey readOnly, idempotent, and non-destructive behavior. The description adds that image input is OCR'd first and that the output is structured JSON, but it adds little beyond that; no rate limits, processing constraints, or empty-input behavior are disclosed. 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 very short and front-loaded with the core action: 'Multimodal extraction. Send an image, text, or both; define your schema; get structured JSON.' There is minor redundancy between 'Multimodal extraction' and 'Unified multimodal field extraction,' but the overall structure 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?

The description covers the main workflow and output type, but with no output schema it leaves the precise JSON return shape vague. It also does not explain what happens when all optional parameters are null, which the schema permits. For a tool with rich annotations and only three optional parameters, this is a moderate 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%, and the field_schema parameter includes an inline example. The tool description itself only mentions 'define your schema of fields,' adding little over the schema, 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 states a specific behavior: multimodal field extraction from images and/or text into user-defined structured JSON. 'Unified multimodal field extraction over images and text' clearly differentiates it from document-specific siblings like document_extract and document_tables, while the custom field-schema aspect distinguishes it from simpler OCR tools.

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

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

The description implies usage by instructing the agent to send image/text and define a schema, but it never explicitly says when to prefer this tool over alternatives or when not to use it. Given the overlapping sibling tools (document_extract, document_query, document_tables), explicit routing guidance is missing.

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 readOnly, idempotent, and non-destructive behavior. The description adds valuable beyond-annotation context: GPU acceleration, tiled processing at 256x256 to manage VRAM, and the maximum output dimension of 8192x8192. This gives the agent a realistic sense of computational constraints and edge cases.

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 with an opening summary, useful technical constraints, and clearly formatted Args and Returns sections. The first two sentences are slightly redundant ('Upscale image resolution' and 'Enhances image resolution'), but overall every section earns its place given there is no output schema.

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

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

With no output schema, the description fully documents the return dict keys. It also covers input formats, scale factor options, the default scale, tile processing, and output size limits. For a two-parameter, read-only tool, nothing essential is missing 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%, so the schema already documents both parameters. The description repeats the same parameter information without adding significant new meaning, though the maximum output dimension is a useful context clue. Baseline 3 is appropriate because the schema carries the parameter documentation burden.

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: 'Upscale image resolution with the Brainiall image-upscaling engine.' It clearly states the tool's function, scale factors (2x or 4x), and distinguishes it from sibling image tools like remove_background and restore_face.

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 implied by the description — use when you need to upscale an image — but there is no explicit when-to-use guidance, no exclusions, and no mention of alternative tools. It provides useful operational context like the 8192x8192 output limit, but stops short of guiding tool selection.

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