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

No annotations are provided, so the description carries full burden. It discloses that existing data is transformed to match the new schema, which is a useful behavioral trait. However, it omits critical safety information such as potential data loss from dropping/narrowing fields, default in-place behavior, permissions required, or reversibility. This is insufficient for a mutation tool.

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 only two sentences, front-loaded with the primary verb and resource, and lists operations efficiently. Every word earns its place with no filler or repetition.

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

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

For a tool with 6 parameters and no annotations or output schema, the description provides a good high-level summary but lacks important behavioral and usage context such as default in-place behavior, destructive implications, or prerequisites. The schema descriptions fill in parameter details, but the description alone is not fully complete for safe 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 provides descriptions for all 6 parameters (100% coverage), so the baseline is 3. The description's mention of operations (widen/narrow/rename/add/drop) maps conceptually to the alter/add/drop parameters but adds no new parameter-level details beyond what the schema already documents.

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 it modifies a data file's schema, enumerating specific operations (widen/narrow/rename/add/drop) and explicitly distinguishing this schema-level tool from sibling record-level tools like chaprola_insert_record or chaprola_update_record. The verb 'Modify' plus resource 'data file's schema' is specific and unambiguous.

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

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

The description implies usage for schema changes, but provides no explicit when-to-use guidance, exclusions, or comparisons to alternatives. Given the large sibling set with overlapping data manipulation tools, clearer direction would be valuable, but the schema-modification context is reasonably evident.

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?

No annotations are provided, so the description carries the full burden. 'Check whether' implies a read-only, non-mutating operation, but it does not explicitly state lack of side effects, behavior when the user is not authenticated, or the exact response shape (e.g., boolean vs. detailed status). This is adequate for a trivial zero-parameter tool but leaves some ambiguity.

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 conveys the purpose without any wasted words. It is optimally concise.

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, no-output-schema status check, the description is nearly complete. It clearly states what is being checked. The only minor gap is that it does not explicitly describe the return value format, but 'whether' strongly implies a boolean, making it sufficiently complete for a simple 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?

There are zero parameters, so the schema is trivially 100% covered. The baseline for zero-param tools is 4, and the description adds meaning by explaining what the status check refers to. No additional parameter documentation is needed.

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

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

The description uses a specific verb 'Check' with a clear resource 'whether the authenticated user has signed the BAA'. This clearly distinguishes it from sibling tools like chaprola_sign_baa (which performs the signing) and chaprola_baa_text (which likely retrieves the 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 gives clear context for when to use the tool: to verify if the authenticated user has already signed the BAA. It does not explicitly mention when not to use it or name alternatives, but the purpose is unambiguous enough for an agent to select it over the signing or text-retrieval 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?

With no annotations available, the description carries full responsibility for disclosing behavior. It states that the tool retrieves text and version and instructs presenting it for review, but it does not clarify whether the operation is read-only, if authentication is required, or if any side effects occur. The brevity leaves room for misinterpretation.

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

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

The description is a single, front-loaded sentence that clearly states the action and purpose. It contains no redundant words and 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, zero-parameter retrieval with no output schema, the description covers the core function and the workflow (review before signing). It could be more complete by explicitly saying the tool does not sign and that signing is handled by a sibling, but the essential information 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?

The tool has zero parameters, and the schema confirms this with an empty properties object. The description adds no extra parameter detail, but none is needed; the baseline for zero parameters is 4, and the description aligns with 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 specifies the exact function: retrieving the current BAA text and version. It also distinguishes from siblings like sign_baa by framing this as the pre-signing review step, making the resource and purpose unambiguous.

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 'Present to human for review before signing' provides clear context for when to use this tool—prior to executing a signature. While it doesn't explicitly name alternatives, the guidance is sufficient to differentiate it from sign_baa and baa_status.

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

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

With no annotations provided, the description carries the full burden. It implies a non-mutating read-only operation ('check if available'), but does not explicitly state the behavior, such as what constitutes 'available' or whether any side effects occur. The description is adequate but lacks explicit transparency.

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

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

The description is a single, concise sentence with no filler words. Every word contributes to the meaning, making it appropriately sized and front-loaded.

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

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

The tool has no output schema, and the description does not explain what the result of the check looks like (e.g., boolean true/false, error message). For a simple validation tool, this is a notable gap, but the description still provides enough to understand the tool's basic function.

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% coverage with a clear description for the username parameter ('Username to check'). The description adds no additional parameter meaning beyond restating that the username will be checked, 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 clearly states the tool's purpose with a specific verb ('Check') and resource ('username availability'), and it distinguishes itself from sibling tools like register and login by indicating its role as a pre-registration check.

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 'before registering' provides clear context for when to use this tool, but it does not explicitly mention when not to use it or alternative tools. Still, the context is sufficient for most use cases.

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

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

With no annotations provided, the description carries the full burden. It discloses several non-obvious behavioral traits: no PROGRAM keyword, no commas, MOVE+PRINT 0 buffer model, SEEK for primary records, and parameter requirements for field addressing. This goes well beyond the schema, but it omits side effects like file overwriting or 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 a single dense paragraph that front-loads the main purpose and then lists vital syntax rules. Although it could be formatted with bullets for better scannability, every sentence contributes directly to correct usage, with no extraneous 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?

For a complex compile tool with no output schema, the description covers purpose, prerequisites, language syntax, and parameter dependencies, making it actionable. It falls short on return values and error behavior, but the reference to the cookbook and detailed syntax rules provide substantial context.

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

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

Schema coverage is 100%, so the baseline is 3. The description adds value by specifying that LET supports only one operation and that P.field/S.field addressing requires primary_format/secondary_format, clarifying the role of those optional parameters. It also imposes syntax constraints on the source parameter, enhancing its 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 opens with a clear verb and resource: 'Compile Chaprola source (.CS) to bytecode (.PR).' This specific phrasing distinguishes the tool from siblings like chaprola_run or chaprola_import, and the file extensions add precision.

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 an explicit prerequisite ('READ chaprola://cookbook BEFORE writing source') and enumerates key syntax rules, providing actionable context for correct usage. However, it does not explicitly state when to prefer this tool over alternatives, so it lacks exclusionary 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?

With no annotations, the description carries the full burden of behavioral disclosure. It explicitly states side effects: deletes .MRG and .IGN after success, and aborts if .MRG was modified during the operation. This is substantial transparency for a mutation tool, though it does not mention error handling details or permissions.

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

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

Two sentences, no fluff. The action, resource, outcome, and side effects are all covered concisely. Front-loaded with the main verb and resource.

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 operation, inputs, and side effects adequately for a moderate-complexity tool. It omits return value details and what happens on abort, but with a simple output and no output schema, this is acceptable. Slightly more detail on the abort behavior could push it to 5.

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 (file and project) already described. The tool description does not add any additional meaning 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 uses a specific verb ('Merge') and identifies the exact resources involved ('.MRG file into its parent .DA'), with a clear outcome ('producing a clean sorted data file'). This distinguishes it from sibling tools like chaprola_merge and chaprola_import, which operate on different inputs/scopes.

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 implies when to use the tool (when a .MRG file needs to be consolidated into its parent .DA), but it does not explicitly state alternatives or exclusions. There is no mention of 'use this instead of...' or prerequisites, so guidance is only inferred.

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

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

No annotations are provided, so the description carries the full burden. It discloses the broad destructive scope ('all associated data') and the passcode requirement. It could add 'permanently' or irreversibility, but delete implies this.

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 concise sentence, front-loaded with the action and scope, and contains no filler.

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

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

For a simple two-parameter destructive tool with no output schema, the description is reasonably complete: it states the action, the scope, and the required confirmation. It could mention response format or irreversibility, but it's sufficient.

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 both parameters have descriptions. The description's mention of passcode confirmation aligns with the schema but adds no extra parameter semantics beyond what the schema already 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 'delete' and identifies the resource 'account', and adds 'all associated data' to clarify scope. This distinguishes it from sibling tools like chaprola_delete_record.

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 context is clear: this tool is for deleting an account, and it explicitly requires passcode confirmation as a prerequisite. It does not name alternatives or when-not-to-use, but the account-specific scope makes it obvious.

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

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

With no annotations provided, the description fully carries the transparency burden. It discloses the soft-delete behavior (marks as .IGN) and the eventual physical removal on consolidation, which are critical behavioral traits. It does not cover error cases or permissions, but the added context exceeds typical descriptions.

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 tightly written sentences with no filler. It front-loads the action and then adds the critical soft-delete detail, earning 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 moderately complex delete operation, the description, combined with the schema, covers the essential aspects: what it deletes, how it identifies the record, and the soft-delete lifecycle. It does not explain return values, but no output schema is defined, and the 'single record' wording sufficiently handles the matching expectation.

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 all three parameters, including the 'where' object semantics ('Field name → value pairs to identify exactly one record'). The description does not add further parameter-level detail, 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 ('Delete') and clearly states the resource ('a single record') and the mechanism ('matched by a where clause'). It distinguishes from sibling tools like 'update_record' and 'insert_record' by focusing on deletion, and from 'consolidate' by noting the soft-delete behavior.

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 this tool is for deleting one record identified by a where clause, which sets the usage context. It does not explicitly name alternatives or exclusions, but the 'single record' constraint and the where clause requirement provide enough guidance for an agent to choose 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?

With no annotations provided, the description carries the full burden. It adds meaningful behavioral context: the URL is presigned, expires in 1 hour, and is restricted to files the user owns. This goes beyond a simple 'download' statement, but it does not detail response format or error conditions, so it is a solid 4.

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 sentence that front-loads the action and key constraints. It is highly concise with zero wasted words, covering purpose, scope, and expiry in a compact form.

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 simplicity of the tool (three required parameters, no output schema), the description is adequately complete. It covers what the tool returns (presigned URL), the scope (owned files), and the expiry. It could mention the response format or potential errors, but those are not necessary for a straightforward download-URL tool. The lack of sibling differentiation slightly reduces completeness.

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 covers all three parameters with descriptions and an enum, so baseline is 3. The description does not add any extra semantic meaning to the parameters; it merely restates that the file must be owned, which is already implied by the schema's project/file/type combination. No added value beyond 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's purpose: obtaining a presigned S3 URL to download a user-owned file, with a specific expiry. It uses a specific verb ('Get') and resource ('presigned S3 URL'), but it does not explicitly distinguish itself from sibling tools like chaprola_import_download or chaprola_fetch, so it misses the top score.

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

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

The description implies the tool should be used when a user needs a temporary URL to download a file they own, and the 1-hour expiry provides context. However, there is no explicit guidance on when not to use it or mention of alternatives, so it remains at the 'implied usage' level.

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

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

With no annotations provided, the description must disclose behavioral traits on its own. It only states the action 'Delete a specific email' without indicating whether the deletion is permanent, requires authentication, or has side effects (e.g., moving to trash). This is a destructive operation where such details are critical.

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, clear sentence with no filler words. It front-loads the purpose immediately and is appropriately sized for a simple tool.

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 delete tool with one parameter and no output schema, the description is minimally adequate. However, it lacks behavioral context (permanence, permissions) and usage guidance, which leaves gaps if complexity were higher. Given the low complexity, it barely meets the minimum viable threshold.

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 describes message_id as 'Message ID to delete' (100% coverage). The description adds no extra meaning beyond the schema, so it defaults to the baseline score of 3.

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 ('Delete') and resource ('specific email from your mailbox'), clearly distinguishing it from siblings like chaprola_email_read/send/inbox and the generic chaprola_delete_record. It leaves no ambiguity about the operation.

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 guidance on when to use this tool versus alternatives such as chaprola_delete_record for non-email records, nor any prerequisites or context. There is no mention of email vs. other resource types or any 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?

With no annotations, the description carries the full burden for behavioral disclosure. It does not mention that the operation is read-only, whether it affects email state, ordering, pagination, or rate limits. Only the phrase 'authenticated user's mailbox' hints at auth requirements, which is minimal.

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 with no redundant words. It clearly states the action and object, earning its place without waste.

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

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

The tool is simple, with two parameters fully described in the schema. However, the description lacks any behavioral context (e.g., default ordering, whether all emails are returned, or how it relates to email_read). Without annotations or an output schema, it is minimally complete but leaves gaps for an agent regarding expected behavior.

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 applies. The description adds no extra meaning beyond the schema's parameter descriptions (limit, before), but it doesn't need to since the schema is complete.

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

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

The description uses a specific verb ('list') with a clear resource ('emails') and scope ('authenticated user's mailbox'). It distinguishes from sibling tools like email_read (single email), email_send, and email_delete by clearly indicating a listing operation.

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

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

The description implies usage (when you want to list emails) but does not explicitly explain when to choose this over alternatives or mention any exclusions. It relies on the tool name and semantics to infer context.

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?

No annotations are provided, so the description carries the full burden. It indicates a non-mutating read operation, but does not disclose what is returned (e.g., full content, headers), error behavior (e.g., when message_id not found), or any side effects like marking as read. The verb 'read' implies no modification, but there is no explicit confirmation or additional context.

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

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

The description is a single, front-loaded sentence: 'Read a specific email by message_id'. Every word contributes, with no filler, and it is concise and clear.

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

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

The tool is simple with one parameter and no output schema, but the description doesn't explain the return format or any edge cases. Given the lack of annotations and output schema, the agent must infer that 'read' means get the email content. This is adequate but has clear gaps, so it is 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?

Schema coverage is 100%: the only parameter 'message_id' has a description 'Message ID from inbox listing'. The tool description adds no extra meaning beyond the schema, so the baseline of 3 is appropriate. The schema already documents the parameter fully.

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

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

The description clearly states the verb 'Read' with a specific resource 'a specific email' and the required parameter 'message_id'. It distinguishes this tool from siblings like chaprola_email_inbox, chaprola_email_send, and chaprola_email_delete by focusing on retrieval of a single email by ID.

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

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

The description implies usage when you have a message_id, and the schema clarifies that this ID comes from inbox listing. It doesn't explicitly exclude alternatives, but the context is clear enough: after listing, use this to read a particular email. No explicit alternatives are mentioned, but the parameter source gives useful context.

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?

No annotations are provided, so the description carries the full burden of behavioral disclosure. It does disclose a key behavior: 'Subject to content moderation.' However, it omits other potentially relevant traits such as authentication requirements, possible delivery delays, or failure modes, leaving some behavioral gaps.

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 sentence of 12 words, front-loaded with the action and purpose. Every word adds value, and the content moderation note is efficiently integrated.

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 email-sending tool, the description covers the core purpose and a notable constraint (content moderation). The rich parameter schema completes the parameter context. Omitted details like authentication prerequisites or return behavior are not critical given the tool's simplicity, so the description is largely 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 fully describes all 5 parameters (100% coverage), so the schema does the heavy lifting. The description adds minimal parameter context by specifying the sender domain, but this is also implied by the schema's 'from' local part description. No additional semantics beyond the schema are provided.

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 ('Send an email') and a specific resource ('from your @chaprola.org address'). It uniquely distinguishes this from sibling email tools (chaprola_email_inbox, chaprola_email_read, chaprola_email_delete) and all other non-email 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 does not explicitly state when to use this tool versus alternatives, but the action of sending an email is unambiguous and usage is implied by the verb. No exclusionary conditions or alternatives are mentioned, which is a slight gap.

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?

No annotations are provided, so the description carries the full burden of behavioral disclosure. It states the export action but does not confirm whether the operation is read-only, whether it modifies or deletes the source files, or if authentication or special permissions are required. The term 'export' implies a non-destructive conversion, but this is left implicit.

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

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

The description is a single, concise sentence that immediately conveys the tool's purpose. It avoids unnecessary detail and is well-structured for quick parsing by an AI agent.

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

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

The tool has no output schema and no annotations, and the description does not explain what the tool returns (e.g., JSON content, file path, success status). For an export operation, the return value is a critical piece of information that is missing. The description covers the action and parameters but leaves the outcome ambiguous.

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 complete descriptions for both parameters (name and project), so schema coverage is 100%. The tool description adds no additional parameter semantics beyond what the schema already offers, which is acceptable given the 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 clearly states the tool exports Chaprola .DA + .F files to JSON, using a specific verb and resource. It differentiates itself from siblings like chaprola_export_report and chaprola_download by specifying the exact file types and output format.

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 need to convert .DA + .F files to JSON) but provides no explicit exclusions or alternatives. It does not mention when to prefer this over chaprola_export_report or chaprola_download, leaving the agent to infer the appropriate context.

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

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

With no annotations provided, the description carries the full burden of behavioral disclosure. It does reveal that output is saved as a persistent .R file in S3, but it omits important behavioral details such as authorization requirements, side effects, overwrite behavior, or what the function returns. For a write-like operation, this is a significant transparency gap.

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 concise, front-loaded sentence with no filler words. It efficiently conveys the main action and output, though the phrasing 'persistent .R file' is slightly unusual. It earns a high but not perfect score due to the lack of any supplementary structure.

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

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

Given the tool has 7 parameters, no annotations, no output schema, and many potentially overlapping siblings, the one-line description is insufficient. It does not explain prerequisites, result format, file naming, or how this differs from related tools, leaving the agent with incomplete operational context.

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

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

The input schema provides descriptions for all 7 parameters, including the enum for format and required fields, so schema coverage is 100%. The description adds no parameter-specific meaning beyond what the schema already provides, making the baseline score of 3 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 (run a .PR program) and the outcome (save output as a persistent .R file in S3), giving a specific verb and resource. However, it does not explicitly differentiate this from sibling tools like chaprola_export, chaprola_report, or chaprola_run, so it falls short of a perfect score.

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

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

The description provides no explicit guidance on when to use this tool versus the many sibling tools, nor does it list any exclusions or prerequisites. It only implies usage when one wants to run a .PR program and persist output to S3, which is not enough context for correct tool selection.

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

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

With no annotations, the description carries the full burden and does disclose several behavioral traits: SSRF protection, rate limit of 20/day, and HTML-to-markdown conversion. These add meaningful context beyond the schema. However, it does not mention error handling, response structure, or behavior for non-HTML content, so it falls short of full transparency.

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 core action, and every word earns its place. It is succinct without sacrificing necessary information, making it highly 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 tool has no output schema, so the description should clarify return values, but it only vaguely says 'clean content.' The inclusion of format options (especially 'json') implies structured output that is not explained. While the core functionality is clear, the description lacks details on response format, error conditions, and edge cases, making it adequate but incomplete.

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 parameters are already well-documented. The description adds a default behavior (HTML converted to markdown) that aligns with the format parameter, but it does not explain parameter specifics or constraints beyond the schema. A baseline 3 is appropriate given the strong 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 clearly states the tool fetches any URL and returns clean content, with HTML converted to markdown. It uses a specific verb and resource, making the core purpose obvious. However, it does not explicitly distinguish itself from sibling tools like chaprola_import_url or chaprola_download, so it misses the sibling differentiation needed for a 5.

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

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

No guidance is provided on when to use this tool versus alternatives. It does not mention scenarios, exclusions, or relationships to sibling tools. The rate limit is a constraint but not a usage guideline. The tool lacks any explicit 'use this when' or 'consider this instead' direction.

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

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

With no annotations provided, the description carries the full burden. 'Inspect' strongly implies a read-only operation, and the explicit return details (field names, positions, lengths, types, PHI flags) give transparency about the output. It does not mention potential side effects or permissions, but the inspection nature is clear.

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

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

The description is a single, front-loaded sentence that conveys the tool's purpose and output without any wasted words. It 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?

The tool is simple (two parameters, both documented) and the description explains the return values. Since there is no output schema, the description compensates by listing the output fields. It does not cover edge cases or error behavior, but for an inspection tool this is adequate.

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

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

The input schema already provides descriptions for both parameters (project and name), giving 100% coverage. The description adds no extra parameter-level detail, 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 clearly states the tool inspects a data file's schema and lists the specific return items (field names, positions, lengths, types, PHI flags). It uses a specific verb ('Inspect') and resource ('data file's schema'), which distinguishes it from sibling tools like chaprola_list or chaprola_fetch.

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: you would use this tool when you need to inspect a data file's schema. However, it does not explicitly say when to use it versus alternatives, nor does it mention exclusions. The usage context is implied but not 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?

With no annotations provided, the description must disclose behavioral details. It states the purpose but omits what happens on success/failure (e.g., return format, status codes) and whether there are side effects. The presence of a 'name' parameter described as 'Name to greet' conflicts with the health-check framing, creating ambiguity about actual behavior.

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

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

The description is a single, front-loaded sentence that directly communicates the tool's core function. No extraneous words or redundant 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?

The tool is simple, but the lack of an output schema means the description should explain what the tool returns or how a health check result is reported. It does not, and the parameter mismatch adds confusion. This incompleteness affects an agent's ability to interpret the tool's 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?

The input schema fully describes the 'name' parameter with a default, so the baseline is 3. However, the description adds no parameter context, and the 'name' parameter seems incongruent with a health check (greeting vs. verification), leaving the agent without clarity on how or whether to use it.

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 is a health check that verifies the Chaprola API is running, using a specific verb ('verify') and resource ('Chaprola API'). This distinguishes it from sibling tools that perform data operations, imports, or account management.

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 identifies the use case: verifying the API is running. While it does not name alternative tools or provide exclusion criteria, the context is clear and sufficient for an agent to know when to invoke this health-check tool.

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?

No annotations are provided, so the description must disclose side effects. It only says 'import', implying file creation, but does not mention whether existing files are overwritten, what happens on failure, or whether authentication is required beyond the BAA note. The BAA warning is a compliance hint but not a full behavioral disclosure.

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

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

Two sentences, front-loaded with the main purpose. The second sentence provides a necessary compliance warning. No waste.

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

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

Despite complete schema, the description lacks information about return values, side effects, or the distinction between json and fhir formats. The BAA warning is useful but incomplete, and the absence of annotations/output schema makes the description insufficient for confident use in complex scenarios.

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 contains full descriptions for all 5 parameters (100% coverage). The description adds no additional parameter meaning; it only reiterates 'JSON data' which is already in the schema. Thus 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 it imports JSON data into Chaprola .F/.DA files. It is specific, but it does not explicitly differentiate from sibling import variants like chaprola_import_url or chaprola_import_process, so it doesn't fully earn a 5.

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

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

No guidance on when to use this tool vs alternatives. The BAA warning is a compliance prerequisite, not a tool-selection guideline. There is no mention of using chaprola_import_url for URL-based imports or chaprola_import_process for pipeline processing.

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?

No annotations are provided, so the description must carry the full burden of behavioral disclosure. It mentions the supported formats and optional AI-powered schema inference, but omits critical details like whether the operation is read-only, requires special permissions, overwrites existing data, or has rate limits. The description only says 'import data' without explaining the impact 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 a single, concise sentence that front-loads the primary action ('Import data directly from a public URL') and efficiently lists formats and features. Every word adds value, with no filler or repetition.

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

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

Given the tool's complexity (5 parameters, no output schema, no annotations), the description is too brief to be fully contextually complete. It explains what the tool does and lists formats, but fails to mention return values, error behavior, side effects, or how it differentiates from similar import tools. The schema covers parameter semantics, but the description leaves significant gaps in behavioral context.

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

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

Schema description coverage is 100%, so all five parameters already have descriptions in the schema. The description adds a small amount of context by noting 'AI-powered schema inference', which hints at the purpose of the 'instructions' parameter, but it does not elaborate on parameter behavior or constraints beyond what the schema already provides. 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 ('Import data directly from a public URL') and lists specific supported formats, making it easy to understand what the tool does. However, it does not distinguish this tool from sibling tools like chaprola_import_url, which likely serves a similar 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 implies usage when you have a public URL and want to import its data, which is a clear context. However, it provides no explicit when-not-to-use guidance or comparisons to alternative tools such as chaprola_import, chaprola_import_url, or chaprola_import_process. The lack of exclusions or alternatives keeps it at an implied-usage level.

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

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

With no annotations provided, the description carries full responsibility for disclosing side effects, safety, and operational behavior. It only states that .F + .DA files are generated, leaving unclear whether the operation is destructive, requires specific permissions, is synchronous, or modifies the original S3 object. This is a significant gap for a processing tool.

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

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

The description is two sentences with no filler words, front-loading the core purpose and the prerequisite. It is appropriately short for the amount of information provided. While it could be more informative, it is concise and structurally clear, earning a score above average.

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

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

The tool has three parameters, no annotations, and no output schema, so the description must explain the full context. It covers the prerequisite and output files but omits critical context such as whether processing is asynchronous, what a successful response looks like, error handling, and how the .F + .DA files are used downstream. This makes it incomplete for an agent trying to select and 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?

The input schema provides 100% coverage with descriptions for all three parameters (name, format, project), so the baseline is 3. The description adds no additional meaning about how parameters affect processing, such as how 'format' influences the .F + .DA output. Since the schema already explains the parameters, the description does not need to repeat them, but it also does not enrich their 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 states the tool processes a file previously uploaded to S3 via presigned URL and names the output files (.F + .DA), which gives a specific action and resource. It is distinct from sibling tools like chaprola_import or chaprola_import_url by focusing on post-upload processing. However, the verb 'Process' remains generic and does not explain what processing entails.

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 'previously uploaded to S3 via presigned URL' clearly implies the prerequisite for using this tool, indicating it should be used after an upload. It does not explicitly mention when not to use it or name alternative tools, such as chaprola_import for initial import or chaprola_import_download for downloading. The context implies a specific workflow stage but lacks explicit 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?

With no annotations provided, the description carries the full burden of behavioral disclosure. It clarifies that the tool returns a presigned URL rather than performing the upload itself, and explains the rationale. It could detail URL expiration or required follow-up steps, but the core behavior is sufficiently transparent.

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, focused sentence that begins with the action and immediately conveys the key value proposition. No unnecessary words or repetition, making it highly 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?

For a simple tool with two well-described parameters and no output schema, the description provides sufficient context: what it does, why it exists, and the type of result (a URL). It does not describe the broader workflow with sibling tools, but this is not essential for using 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?

The input schema already provides full descriptions for both parameters (100% coverage). The tool description adds no additional parameter-level meaning, 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 the tool's function clearly: obtaining a presigned S3 upload URL. The added context about bypassing the 6MB API Gateway limit distinguishes it from other import-related sibling tools, making the purpose unambiguous.

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 indicates when to use this tool: for large files that exceed the standard API Gateway limit. It does not name specific alternatives or exclusion conditions, but the context is clear enough for an agent to identify 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?

With no annotations, the description carries full responsibility for disclosing side effects. It states the tool builds an index file, implying a write operation, but does not mention whether it creates a new file, overwrites an existing one, requires special permissions, or affects the original data file. This leaves significant behavioral uncertainty.

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

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

The description is a single, concise sentence that is front-loaded with the action and resource. It contains no unnecessary words and is 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?

With no output schema and no annotations, the description does not explain what the agent will receive after calling the tool (e.g., success message, index file path), nor any prerequisites like whether the file must exist or how the project is used. It is minimal and leaves the agent guessing about the full workflow.

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 provides descriptions for all three parameters (file, field, project) with 100% coverage, so the baseline is 3. The description adds no additional meaning beyond what the schema already contains, such as format details or relationships between 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 the tool's function: 'Build an index file (.IDX) for fast lookups on a field.' It uses a specific verb ('Build') and resource ('index file'), and explains the purpose. This distinguishes it from sibling tools like 'sort' or 'search' by focusing on index creation.

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 any exclusions or prerequisites. The phrase 'for fast lookups' implies a use case, but it does not explicitly tell the agent when to choose this tool over similar data operations like 'query' or 'search'.

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?

Without annotations, the description carries the burden of behavioral disclosure. It does disclose a key behavior: the record appears at the end of the file until consolidation. However, it does not mention prerequisites (e.g., permissions, file existence), reversibility, or any potential side effects, which would be valuable for a mutation tool.

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

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

The description is a single, front-loaded sentence that conveys the action, target, and a key behavioral consequence. Every word earns its place, with no repetition of schema 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?

The description is adequate for a simple insert operation, but there is no output schema and no mention of return values or error behavior. The note about 'until consolidation' provides context, but the description could be more complete by explaining what happens after consolidation or how to verify the insert.

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% coverage with descriptions for all three parameters. The tool description adds no additional semantic detail beyond what the schema states, 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 uses a specific verb ('Insert') and resource ('a data file's merge file (.MRG)'), which clearly distinguishes this from sibling tools like update_record, delete_record, and consolidate. The mention of .MRG makes the target concrete and unambiguous.

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

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

The description implies usage for adding new records but does not explicitly state when to use this tool versus alternatives like update_record or delete_record. The phrase 'until consolidation' hints at a workflow, but there is no explicit 'when to use' or '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?

No annotations are provided, so the description carries the full burden. It only states the core action and does not disclose behaviors like return format, whether directories are included, or case sensitivity of the wildcard pattern.

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

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

The description is a single, front-loaded sentence with no redundant information. It is concise 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?

The tool is simple with two parameters, but without an output schema or annotations, the description should explain return values or limitations. The current description is adequate for basic understanding but leaves gaps about the output format and listing behavior.

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 does not add meaning beyond the schema; it merely restates the optional wildcard pattern already documented in 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 lists files in a project with an optional wildcard pattern. It uses a specific verb and resource, and it is distinct from sibling tools like chaprola_schedule_list, which lists schedules.

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

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

No guidance is provided on when to use this tool versus alternatives such as chaprola_query or chaprola_search. The description implies usage but does not state exclusions or alternative 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?

With no annotations provided, the description carries full responsibility for behavioral disclosure. It prominently warns that the previous API key is invalidated, which is a critical side effect. However, it doesn't mention other potential behaviors such as session expiration or response format, though the core destructive behavior is well covered.

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

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

The description is a single, front-loaded sentence that communicates the core action and a critical warning without any filler. Every word contributes meaningful information, making it highly 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 login tool with no output schema and no annotations, the description covers the essential aspects: what it does and a key side effect. It implies the return of a new API key, which is sufficient for an agent to understand the outcome. Minor gaps exist around response structure, but the description is adequate for invocation.

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

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

The input schema already provides 100% coverage with descriptions for both parameters (username and passcode). The description adds no additional parameter semantics beyond 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 clearly states the action (login) and the outcome (get a new API key), which is specific and distinct from sibling tools like chaprola_register or chaprola_hello. The warning about invalidating the previous key adds further clarity about the tool's core function.

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

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

The description implies usage for existing users needing a new API key, but does not explicitly state when to use this versus alternatives like register or check_username. The warning about invalidation provides contextual guidance against casual use, but lacks explicit when-to-use/when-not-to-use direction.

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?

No annotations are provided, so the description carries the full burden of behavioral disclosure. It mentions the sorted and .F requirements, but does not disclose what happens if inputs violate these, how the key is used, whether overwriting occurs, error handling, or return values. This is a significant gap for a merge 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 a single, well-structured sentence that is front-loaded with the core purpose. It 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?

Given that there are 5 required parameters, no annotations, and no output schema, the description is too minimal. It omits key role, failure modes, output format, and behavior details, making it inadequate for an agent to fully understand the tool's behavior and edge cases.

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 context about sorted and .F format, but does not add meaningful parameter-level semantics beyond the schema—e.g., it does not explain the key field's role or relationship between file_a, file_b, and output.

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 'Merge two sorted data files into one' with a specific verb and resource, and adds a format requirement (.F). It is self-explanatory, but does not explicitly distinguish itself from similar sibling tools like chaprola_consolidate, so it falls short of a 5.

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

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

The description implies the intended use case—merging two sorted, same-format files—and mentions a key prerequisite (same format). However, it provides no explicit guidance on when to choose this tool over alternatives, nor any exclusions or conditions like key requirements.

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?

No annotations are provided, so the description carries the full burden of behavioral disclosure. It states the operation but does not mention side effects, whether it runs synchronously or asynchronously, return value behavior (e.g., job_id), or required permissions. This is a significant gap for an execution tool.

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

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

The description is a single, front-loaded sentence with no filler. 'Run HULDRA nonlinear optimization' immediately conveys the core action, and the remainder specifies the key mechanism. 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?

With 8 parameters, nested array objects, no annotations, and no output schema, a one-sentence description is insufficient. The agent is left to infer return behavior, async execution implications, prerequisites, and how this tool relates to compile/run/status siblings.

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 useful relationship between 'program' and 'objectives' by calling the .PR an 'objective evaluator', but it does not add meaning for elements, primary_file, async_exec, or other parameters beyond what the schema already states.

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 resource ('HULDRA nonlinear optimization') with a clear mechanism ('compiled .PR as the objective evaluator'). It implicitly distinguishes itself from siblings like chaprola_run by naming optimization, though it does not explicitly name alternative 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?

Usage is implied by the description: use this when you need nonlinear optimization with a compiled .PR objective evaluator. However, there is no explicit guidance on when not to use it, prerequisites like compiling the .PR first, or alternatives such as chaprola_optimize_status for checking progress.

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?

No annotations are provided, so the description carries the full burden. 'Check status' strongly implies a read-only, non-mutating operation, which is a key behavioral trait. However, it does not disclose what the response contains, whether it can be called repeatedly for polling, or any rate limits/auth requirements. It is minimal but not misleading.

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

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

The description is a single front-loaded sentence that states exactly what the tool does. No wasted words or redundant details. It is appropriately concise for a simple status-check tool.

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 low-complexity with full schema coverage, but there is no output schema and no annotations. The description could have explained what the status response looks like or how to interpret it for polling. It is adequate for a basic status check but leaves some uncertainty about return values.

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?

Input schema covers 100% of both parameters (job_id and project) with clear descriptions. The tool description adds no additional parameter semantics, and 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 specific verb ('check') and resource ('status of an async optimization job'), clearly distinguishing it from siblings like chaprola_optimize (which likely creates the job) and other status tools like chaprola_run_status. It is unambiguous and 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?

The description implies usage after submitting an async optimization job, but it does not explicitly state when to use this tool vs alternatives, nor does it mention exclusions or prerequisites. The schema hint about job_id from the /optimize response adds context, but the description itself lacks direct usage 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?

No annotations are provided, so the description must carry the full burden of behavioral disclosure. It states the main action but omits side effects, permission requirements, overwrite behavior, or reversibility. For a publish operation, this is a significant transparency gap.

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

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

The description is a single, concise sentence that conveys the core purpose without any redundant wording or filler. It is front-loaded and every word contributes to the meaning.

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 4 parameters and no output schema, the description is too minimal. It omits prerequisites (e.g., must be compiled), the relationship to the /report endpoint, and role of each parameter, leaving the agent to infer too much from the schema alone.

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 covers 100% of parameters with individual descriptions, so the baseline is 3. The tool description adds no additional parameter context, maintaining the baseline without enhancement.

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 ('Publish'), the resource ('a compiled program'), and the mechanism ('for public access via /report'). This distinguishes it from siblings like compile and unpublish, making the purpose unambiguous.

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

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

The description implies the tool is used after compiling a program to expose it via /report, but does not explicitly state prerequisites, alternatives, or when not to use it. Sibling names like unpublish provide contrast, but the guidance is implicit 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?

With no annotations, the description must disclose behavioral traits. It lists query operations but does not state whether this is strictly read-only, how it handles limits or offsets, what happens when data is missing, or what the response format looks like. The implicit read-only nature of a 'query' is not made explicit, and no side-effect or error behavior is described.

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 immediately states what the tool does. Every word contributes value, with no redundancy or filler. It is appropriately front-loaded and concise.

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 tool has 11 parameters, nested objects, and no output schema, creating a need for richer context. The description only lists capabilities and fails to explain required inputs, join/pivot/mercury object structures, return values, pagination, or integration with sibling tools. It is too sparse for the complexity involved.

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 already explains all parameters including nested objects. The description adds high-level feature names (WHERE, SELECT, aggregation, etc.) that map to parameters, but it does not add semantics beyond those already present in the schema. It earns the baseline score of 3.

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

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

The description clearly identifies the tool as a data query operation with specific capabilities (WHERE, SELECT, aggregation, ORDER BY, JOIN, pivot, Mercury scoring). It is distinct from simpler lookup tools, but it does not explicitly distinguish itself from sibling tools like chaprola_search or chaprola_fetch, so it stops short of a 5.

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

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

No guidance is provided on when to use this tool versus alternatives such as chaprola_search or chaprola_sort. It does not mention prerequisites like the required project and file parameters, nor does it state any exclusions or limitations. The usage context is only implied by the word 'query'.

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

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

With no annotations provided, the description carries the burden of behavioral disclosure. It meaningfully states that registration returns an API key and instructs to save it immediately, implying the key may not be retrievable later. This is useful, non-obvious behavioral context, though it doesn't detail edge cases like username conflicts.

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

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

The description is a single, front-loaded sentence that states the action and the critical return value. Every word earns its place; no fluff 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?

For a simple registration tool with two required parameters and no output schema, the description is complete enough: it declares the operation, the return value, and a critical follow-up action. It doesn't cover error scenarios, but those are likely discoverable via sibling tools like check_username.

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 parameters (username, passcode) already documented in the input schema. The description adds no additional parameter-level meaning, 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 and resource ('Register a new Chaprola account') that clearly distinguishes it from sibling tools like chaprola_login and chaprola_check_username. It also states the key return value (API key), making the purpose unambiguous.

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 for when to use the tool: when creating a new Chaprola account. It does not explicitly mention alternatives or when not to use it, but the purpose is distinct enough among siblings that the guidance is adequate without 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?

With no annotations provided, the description carries the full burden. It discloses that no auth is required and that publishing is a precondition, which is useful. However, it does not mention whether the program execution can have side effects or any potential resource consumption, leaving behavioral transparency incomplete.

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 compact two-sentence structure that front-loads the primary action. Every sentence adds value without redundancy or excessive detail.

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

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

The tool has no output schema, yet the description simply says 'return output' without specifying the format or structure of that output. It also omits potential error conditions like what happens if the program isn't published. For a simple run tool this is somewhat adequate, but the lack of output detail is a clear 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 all three parameters. The description adds no extra parameter-level detail beyond what the schema provides, 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 clearly states the tool runs a published program and returns output, using a specific verb and resource. The phrase 'published program' and the reference to '/publish' distinguish it from siblings like chaprola_run or chaprola_compile.

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

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

It provides clear context by specifying that the program must be published first via /publish and that no auth is required. It does not explicitly mention alternatives, but the precondition clearly implies when to use this tool.

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

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

With no annotations provided, the description carries the full burden of behavioral disclosure. It only states that the tool executes a compiled program and gives an async threshold. It does not disclose whether the execution has side effects, what happens after completion, how jobs are monitored, or any error/return behavior. The async tip is helpful but insufficient for a tool with no safety hints.

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

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

The description is two sentences, front-loaded with the core purpose, and every word earns its place. No fluff or 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?

The tool has 7 parameters, no annotations, and no output schema. A one-line description plus a single usage tip is inadequate. The agent is left without information about what a compiled .PR program does, what the execution returns (e.g., job_id format), or how to handle failures. The absence of an output schema makes the description's silence on return values particularly problematic.

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 baseline is 3. The description adds value by linking the async_exec parameter to a concrete condition ('large datasets >100K records'), which is beyond the schema's simple 'If true, run asynchronously...' This augments one parameter meaningfully, even though it doesn't address all seven.

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: 'Execute a compiled .PR program.' This is a specific verb and resource, and it distinguishes the tool from siblings like chaprola_compile (which compiles) and chaprola_run_status (which checks status). The purpose is unambiguous.

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 situational guideline: 'Use async:true for large datasets (>100K records).' This gives context for when to set a key parameter, though it does not explicitly mention alternatives or when not to use this tool. The guidance is useful but limited to the async decision.

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

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

With no annotations, the description must carry the full burden. It fails to disclose whether the program can mutate data, whether execution is asynchronous, or what happens on errors. Running a program against every record could be destructive, and the description does not mention any safeguards 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 two sentences, front-loaded with the primary action, and the second sentence adds valuable use-case context. Every word earns its place with no redundant 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?

The tool has moderate complexity (5 params, many siblings, no annotations, no output schema). The description explains what the tool does and when to use it, but omits critical behavioral information such as potential side effects, execution lifecycle, or how to retrieve results. This leaves the agent under-informed for a bulk processing 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?

Schema description coverage is 100%, so the schema fully documents all parameters. The description adds no additional parameter-specific meaning beyond the schema, which already explains file, where, program, project, and where_logic. 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 a compiled .PR program against every record in a data file, with specific verb and resource. It distinguishes itself from siblings like chaprola_run and chaprola_update_record by emphasizing iteration over all records and listing use cases (scoring, bulk updates, conditional logic).

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 provides use cases: 'Use this for scoring, bulk updates, conditional logic across records.' It also references CHAPRPG for legacy context. However, it does not explicitly state when not to use it or name alternative tools for single-record runs or simple queries.

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

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

With no annotations, the description carries full burden. It discloses that full output is returned when done, but does not specify intermediate status behavior, polling semantics, error handling, or whether it is read-only. This is minimal disclosure for a status tool.

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, front-loaded, no 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?

Despite simple params, the description lacks details about what the status response looks like before completion, which is essential for an async status tool. No output schema exists, so the description should compensate but does not. Sibling tools and absence of annotations increase the need for more context.

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

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

Schema coverage is 100% with both parameters described, so the schema carries the parameter documentation burden. The description adds no additional parameter meaning, but 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 clearly states the verb 'Check status' and the resource 'async job', and adds the key behavior 'Returns full output when done'. It distinguishes from sibling run tools by focusing on status, but does not explicitly differentiate from other *_status tools like chaprola_optimize_status or chaprola_baa_status.

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 on when to use this tool versus alternatives. The description implies it follows an async run, but does not mention chaprola_run or state exclusions. Sibling status tools exist, creating potential ambiguity.

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

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

With no annotations, the description must disclose behavior. It mentions important limits (max 10 schedules/user, 15-min minimum cron interval) which are useful. However, it omits other behavioral aspects like idempotency on duplicate names, the underlying persistence of schedules, or what the response contains (e.g., schedule ID for later management). The lack of annotation coverage raises the burden, and this description only partially meets it.

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, front-loaded with the core action ('Create a scheduled job') and then a brief, useful constraint. Every word earns its place; no wasted or 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 tool's complexity (5 params, nested body, enum) and lack of output schema, the description is adequate but incomplete. It would benefit from mentioning the returned schedule object or how to reference created schedules with siblings, and possibly cron timezone behavior. The schema covers parameters, but the high-level context around scheduling lifecycle 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%, so parameter semantics are already fully documented in the schema. The main description adds no parameter-level details beyond the schema, but it also does not need to. The baseline of 3 applies because the description does not add meaningful value over the schema's 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 states a specific action ('Create a scheduled job') and the resource ('a Chaprola endpoint on a recurring cron'). It distinguishes itself from sibling tools like chaprola_schedule_list and chaprola_schedule_delete by focusing on creation, making the purpose unambiguous.

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: if you want to schedule a recurring Chaprola endpoint invocation, use this tool. However, it does not explicitly mention alternatives or exclusions, such as when to use direct endpoint calls or how to manage existing schedules via list/delete siblings. The constraints (max 10 schedules, 15-min interval) offer some guidance but not enough for a 4.

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?

No annotations are provided, so the description carries the full burden. It only states the action 'delete' without disclosing whether the deletion is permanent, irreversible, or has side effects. It also does not mention error handling or permissions. This is a significant gap for a destructive 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 a single, concise sentence that is front-loaded with the action and resource. It contains no filler or redundant information beyond what is necessary, making it 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?

Given the simplicity of the tool (one required param, no output schema), the description is somewhat complete but lacks behavioral context such as permanence or error conditions. For a destructive mutation tool with no annotations, more detail would be expected, but the minimal scope keeps it from being severely deficient.

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% coverage: the 'name' parameter is described as 'Name of the schedule to delete'. The description's 'by name' simply echoes this, adding no additional meaning. The schema already carries the semantic weight, so a 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 "Delete a scheduled job by name" uses a specific verb (delete) and resource (scheduled job), clearly distinguishing it from sibling tools like chaprola_schedule_list (list) and chaprola_schedule (create/update). The inclusion of 'by name' also identifies the key parameter.

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

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

The description implies usage: use this tool when you need to delete a scheduled job by its name. However, it provides no explicit when-to-use vs alternatives, no prerequisites, and no exclusions. It is adequate but minimal.

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

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

With no annotations, the description carries the burden of transparency. It implies a read-only operation ('List') and specifies the output contents, but it does not disclose operational details such as pagination, limits, sorting, or any potential side effects. The description is clear but not deeply behaviorally 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 a single, front-loaded sentence that efficiently conveys the tool's purpose. Every word 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 parameterless list tool, the description adequately covers the return values. It lacks explicit mention of pagination or ordering, but given the low complexity and the explicit statement of what is included, it is sufficiently complete. An output schema would add detail, but none is provided.

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

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

The tool has zero parameters and the schema coverage is 100%, so there are no parameter ambiguities. The description adds no parameter information, but none is needed, earning the baseline of 4 for zero-parameter tools.

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

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

The description uses a specific verb 'list', identifies the resource 'scheduled jobs', scopes to 'the authenticated user', and states the included details ('run history and next execution time'). This clearly distinguishes it from siblings like chaprola_schedule_delete and chaprola_schedule.

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 no guidance on when to use this tool versus alternatives, nor does it mention exclusions or related tools. It purely states what the tool does without contextualizing its usage relative to sibling 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?

With no annotations provided, the description carries the full burden. It discloses the rate limit (10/day per user) and what the tool returns, adding context beyond the input schema. It does not explicitly state lack of side effects, but as a search tool this is implied. It could be improved by noting it doesn't modify any data or require authentication, but the provided information is useful.

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, each with a distinct purpose: what it does, what it returns, and a rate limit. It is front-loaded with the core purpose and contains no filler. Every sentence adds value.

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 straightforward web search tool with no output schema, the description covers the key aspects: purpose, return content, optional summary, and a rate limit. The input schema already provides parameter details, so the description effectively completes the picture. No critical 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?

Schema description coverage is 100% for all three parameters (query, count, summarize), so the baseline is 3. The description only mentions the optional AI-grounded summary, which is already described in the schema. It doesn't add additional meaning beyond what the schema provides, such as formatting or constraints.

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 'Search the web via Brave Search API' with a specific verb and resource, and it differentiates from other tools by describing the return format (titles, URLs, snippets). Among the sibling tools, no other tool is a web search, so there's no ambiguity.

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 context: it returns titles, URLs, snippets, and optional AI summary, with a rate limit. Although no alternative tools are explicitly mentioned, the behavior is specific enough that an agent can infer when to use it. There are no exclusions or counter-indications, but it doesn't explicitly compare to other search-like tools like chaprola_query.

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

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

With no annotations, the description carries the full burden. It discloses critical behavioral constraints: it must never be invoked automatically, requires prior human approval, and is specific to PHI contexts. This exceeds typical transparency and clearly signals the irreversible/contractual nature of signing.

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 (3 sentences), front-loaded with the purpose, and uses a strong STOP directive to highlight the prerequisite. Every sentence contributes critical information without waste.

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

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

For a simple signing tool with no output schema and 100% schema coverage, the description fully covers the safety protocol, the use case (PHI vs non-PHI), and the required sequence. No significant gaps remain.

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 with descriptions for all three parameters (organization, signatory_name, signatory_title). The description does not add further 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 clearly states 'Sign the BAA', which is a specific verb+resource. It is distinguishable from sibling tools like chaprola_baa_text (which shows the text) and chaprola_baa_status (which checks status). The purpose is unambiguous.

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 when this tool is needed ('Only needed for PHI — non-PHI data works without a BAA') and provides a mandatory prerequisite: call chaprola_baa_text first, show the full text, and obtain explicit typed approval. It also gives a clear negative instruction ('Never sign automatically'), which is excellent usage 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?

With no annotations, the description carries the full burden. It discloses a critical behavioral trait: 'Modifies the file in place', which signals mutation and potential destructiveness. However, it doesn't mention reversibility, required permissions, error behaviors, or how multiple sort fields are prioritized, leaving notable gaps.

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

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

Two sentences, zero waste. The first sentence states the core functionality, the second notes the side effect. It is front-loaded and 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 moderately complex tool (sort_by with directional and type options), the description is minimal. It explains the overall action and side effect but does not elaborate on sort priority, type handling, or file format. The schema covers parameter structure, but the tool's behavior beyond 'in place' is under-specified.

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% for the three parameters, so the baseline is 3. The description adds no extra semantics beyond what the schema already provides; it just says 'by one or more fields' which aligns with sort_by. No additional meaning is provided for file or project.

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 'Sort' and identifies 'a data file' as the resource, with the detail 'by one or more fields'. This clearly distinguishes it from sibling tools like chaprola_merge or chaprola_format, and the second sentence adds a key qualifier about in-place modification.

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 stating the action and resource, but it does not explicitly state when to use this tool versus alternatives, nor does it mention any exclusions or prerequisites. Since the purpose is obvious, it's not completely vague, but it lacks direct 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?

No annotations are provided, so the description must fully disclose behavioral traits. It states the tool removes public access but does not mention whether the program remains accessible to owners, if the action is reversible, or any side effects. For a mutation operation, this is minimal disclosure.

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 sentence with no superfluous words, front-loading the action and object. It is appropriately sized for the tool's simplicity and 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?

With no annotations and no output schema, the description is sparse. It fails to clarify that unpublishing is distinct from deleting or whether the program remains available in a private state. For a mutation tool, this lack of context makes it incomplete.

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 covers both parameters (name and project) with full descriptions, achieving 100% schema coverage. The description adds no additional parameter semantics, 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 'remove' targeting 'public access from a published program', clearly distinguishing it from related tools like chaprola_publish and chaprola_delete_record. It precisely identifies the resource and the action.

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

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

The description implies the tool is for programs that are currently published, but it does not explicitly state when to use it versus alternatives such as delete_record or publish. No exclusions or alternative tool mentions are provided, leaving the usage context only partially 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?

With no annotations, the description carries the burden of disclosing behavior. It does so unusually well by explaining the two execution paths: in-place update versus marking old record ignored and appending to a merge file. Missing details like error handling and return values prevent a higher 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?

Two sentences, front-loaded with the core action and immediately followed by the key behavioral nuance. Every word earns its place; no filler or 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?

Given no annotations and no output schema, the description covers the main behavioral complexity well. It leaves some gaps—such as what happens when no record matches, how sort-key is defined, and what the tool returns—but overall it is sufficiently complete 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?

Schema coverage is 100%, so the baseline is 3. The description adds some context around the 'where' clause and the effect of sort-key changes on the 'set' parameter, but it does not substantially enhance individual parameter understanding beyond what the schema already 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 clearly states the action ('Update fields'), the target resource ('a single record'), and the matching mechanism ('where clause'). It naturally distinguishes itself from insert/delete siblings by focusing on updating an existing record.

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: use this when updating a single existing record identified by a where clause. It does not explicitly name alternatives or exclusionary cases, but the purpose is unambiguous enough to guide tool selection among CRUD siblings.

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