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 explains the underlying process (exports data dictionary, inserts field, imports back) and notes the operation is atomic, giving insight into side effects and failure behavior. It stops short of detailing permissions or reversibility, but the atomicity note partially addresses that. This is substantially more transparent than 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 structured with a clear purpose statement, a brief process explanation, and a well-organized Args list. Each parameter gets a concise, informative one-liner without redundant text. The length is justified by the 14 parameters, and the front-loaded purpose makes it scannable.

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 tool with 14 parameters, the description covers all necessary aspects: purpose, process, parameter semantics, and return value (confirmation message with count). The output schema is also available, so the description need not elaborate further on return structure. Given the complexity, this is highly complete.

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

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

Schema description coverage is 0%, so the description must compensate. It does so exceptionally: every parameter is explained with meaning, formatting rules (e.g., field_name lowercase/underscores, choices format), and contextual notes (e.g., ignored for other types). This goes far beyond the schema's field names and types.

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 'Add a new field to an existing instrument,' which clearly states the specific action and target resource. This distinguishes it from related tools like add_instrument (adds an instrument) and update_field (modifies an existing field), making its 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 provides clear context: it is for adding a new field to an existing instrument. It does not explicitly mention alternatives or exclusions, such as warning to use update_field for modifications, but the purpose is so direct that the intended usage is apparent. A brief note contrasting with update_field would elevate this, but current guidance is sufficient.

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 present, so the description must carry the behavioral transparency burden. It discloses that the tool creates a placeholder descriptive field (a side effect), explains the REDCap constraint that requires at least one field per instrument, and notes the default display label behavior. It also states the return value. This is meaningful behavioral information beyond simple 'creates an instrument.'

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

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

The description is well-structured with a clear purpose statement, an explanatory paragraph, a note, and an Args/Returns section. Every sentence provides useful information without redundancy. It is appropriately sized for the tool's simplicity.

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 one parameter and an output schema, the description covers all essential aspects: what the tool does, the side effect of creating a placeholder, the parameter format, and the return value. The note about label modification adds relevant operational context. No critical gaps are apparent.

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 only lists form_name as a string with no description, so schema coverage is 0%. The description compensates fully by defining form_name as 'Internal name for the instrument (lowercase, underscores, no spaces),' which adds crucial format constraints and semantics that are absent from 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 begins with a clear verb+resource: 'Add a new instrument (form) to the project.' It distinguishes this from the sibling tool add_field by explaining that a placeholder field is added and can later be replaced with real fields via add_field. This makes the tool's specific role 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 context on when to use this tool — when adding a new instrument — and relates it to the subsequent use of add_field. It does not explicitly say 'use this instead of X' but clearly implies the workflow and notes that the display label can only be changed in the UI, which is practical guidance for users.

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 the return type (confirmation or error) but does not mention potential side effects, permissions, or behavior on conflict. For a mutation operation, this is a significant 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 concise and well-structured, with a clear purpose sentence, an Args section, and a Returns section. No unnecessary words.

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

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

The tool is relatively simple (3 params, no nested objects). The description covers the main purpose, parameters, and a notable error condition. Given no annotations, it is fairly complete, though it lacks behavioral details like idempotency or override 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 coverage is 0%, so the description must compensate. It does so by explaining each parameter's meaning, including an example for 'event' and a default for 'arm_num'. This adds value beyond the raw 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 action ('Assign an instrument to an event') and the context ('in a longitudinal project'). It is specific and distinguishable from siblings such as 'unassign_instrument_from_event'.

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 (longitudinal project) and mentions the error condition if the project is not longitudinal. However, it does not explicitly compare to alternative tools or mention when not to use it.

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

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

With no annotations, the description carries the full burden. It discloses the return behavior ('Returns all fields whose branching_logic or calculated formula reference field_name') and implies a read-only operation via verbs like 'Find' and 'Returns'. It does not explicitly state 'does not modify' but the purpose and actions are clear enough.

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

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

The description is concise and well-structured: purpose (first sentence), usage guidance (second sentence), Args and Returns sections. Every sentence adds value with no redundancy.

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

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

For a simple tool with one parameter and an output schema, the description covers purpose, when to use, parameter meaning, and return format. It is fully contextual for the task at hand.

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

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

Schema description coverage is 0%, but the description compensates by defining field_name as 'Variable name to search for' in the Args section. This adds meaning beyond the schema's simple title 'Field Name'.

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

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

The description states a specific verb and resource: 'Find every field that references a given field in branching logic or calculations.' It clearly distinguishes from sibling tools like validate_branching_logic (which validates logic) and remove_field (which removes fields) by focusing on reference detection.

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: 'Run this before removing or renaming a field to avoid breaking the project.' It tells the agent when to use the tool but does not mention alternatives or when not to use it, so it falls short of an explicit 5.

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

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

With no annotations, the description fully discloses key behaviors: branching logic is cleared because it references original field names, field_prefix prevents collisions, and the return is a confirmation message with the count of cloned fields. This goes beyond basic expectations and flags a non-obvious side effect.

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

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

The description is well-structured and front-loaded with the primary action, followed by a caveat, then parameters, then return value. Every sentence adds value with no fluff or repetition, making it appropriately concise for the tool's complexity.

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 purpose, all parameters, a key edge case (branching logic), and the return value. Given the output schema exists (though not shown), and the tool has only three parameters, the description is complete enough for an agent 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?

Schema description coverage is 0%, so the description must explain each parameter. It does so with clear definitions: source_form (internal name of source), new_form_name (internal name of new instrument), and field_prefix (example 'v2_' turning 'age' into 'v2_age'). This fully compensates for the schema gaps.

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 clones all fields of an instrument into a new instrument, using a specific verb and resource. It distinguishes from siblings like rename_instrument or delete_instrument by focusing on the cloning action and the field_prefix mechanism.

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 for when to use the tool (when cloning an instrument with all fields) and mentions a critical follow-up (update_field for branching logic). However, it does not explicitly name alternative tools or state when not to use it, so it falls short of a 5.

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

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

No annotations exist, so the description must disclose side effects. It mentions the confirmation message but omits consequences such as impact on associated events/records, irreversibility, or permission requirements.

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

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

Short, front-loaded action sentence, with structured Args/Returns sections. Every sentence earns its place without 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 is simple with one param and an output schema, but the description lacks usage context and safety caveats. It covers core purpose and param, yet not enough to fully guide selection among sibling delete tools.

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

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

The schema has one param 'arms' with no description; the description clarifies it expects 'List of arm numbers to delete,' adding essential meaning beyond the raw array-of-strings 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?

Clear verb 'delete' with specific resource 'arms' in 'longitudinal REDCap project.' Distinct from sibling delete_* tools by naming the exact resource type.

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

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

No guidance on when to use vs alternatives or on prerequisites. The description simply states the action with no exclusions, alternatives, or contextual conditions.

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 disclosing behavioral traits. It does not mention that deletion is permanent, the impact on associated data, permission requirements, or error behavior. The description only states the action and return value, which is insufficient 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 exceptionally concise, with a clear structure using Args and Returns sections. Every sentence contributes meaningful information, 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 deletion tool, the description is incomplete. It lacks critical context about side effects, reversibility, ordering, or relationships with other entities (e.g., whether deleting events also affects assigned instruments). The presence of an output schema helps with return values, but the overall description does not sufficiently prepare the agent for a destructive operation.

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 describes 'events' as an array of strings with no further detail. The description adds that it is a 'List of unique event names', which clarifies the semantic meaning and adds a uniqueness constraint. However, it does not specify the exact format of event names or how they should be obtained, leaving some ambiguity.

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

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

The description clearly states the operation ('Delete events') and specifies the resource ('events') within a 'longitudinal REDCap project'. This distinguishes it from sibling tools like delete_file and delete_records, which target different resource types.

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 any preconditions or constraints (e.g., whether events with data can be deleted). It simply states the action without context for decision-making.

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 transparency burden. It clearly states the destructive action ('Delete') and the target (file attachment), plus the return type (confirmation message). However, it omits details such as irreversibility, permission requirements, or whether deletion is permanent from storage, which are important 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 concise and well-structured with Args and Returns sections. Every sentence adds value, and there is no redundant or vague wording.

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 purpose, all parameters, and the return value, which is sufficient for a simple file deletion tool. However, it lacks side-effect caveats such as permanence or prerequisites, and with no annotations, a bit more context could be added, though not essential for basic usage.

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

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

Schema description coverage is 0%, but the description fully compensates by defining all three parameters in the Args section. It adds semantic meaning: record is the ID, field is the file upload field, and event is for longitudinal projects only, clarifying the optional param's purpose.

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 action verb ('Delete') with a clear resource ('file attachment from a REDCap record field'). It distinguishes this tool from similar siblings like delete_records and export_file/import_file by scoping to file attachments on record fields.

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 Args section implies usage by specifying required record and field, and notes that event applies only to longitudinal projects. However, it does not explicitly mention alternatives or state when not to use this tool versus delete_records or other sibling tools, so guidance is implied rather than explicit.

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

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

With no annotations provided, the description carries the transparency burden. It discloses that all fields belonging to the instrument are removed, the operation fails if the record-ID field is present, and returns a confirmation message with the count of removed fields. It does not mention permissions or irreversibility explicitly, but the destructive 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 compact and well-structured, leading with the core action, then detailing behavior, followed by an Args section and a Returns section. Every sentence serves a purpose without redundancy.

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

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

For a single-parameter tool with an output schema, the description provides complete contextual information: what happens (all fields deleted), a key constraint (record-ID field rejection), and the return format (confirmation with count). The AI agent has sufficient information to invoke it correctly.

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

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

The schema only provides 'Form Name' with no description (0% coverage), so the description's 'form_name: Internal name of the instrument to delete' adds crucial semantic meaning, clarifying that the ID is the internal name, not the display label.

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 'Delete an instrument and all its fields from the project,' which specifies the verb, resource, and scope. This also distinguishes the tool from siblings like delete_records (removes data) and remove_field (removes a single field).

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 when deleting an entire instrument with all its fields, but it does not explicitly mention alternatives or when-not-to-use cases. It does note that REDCap rejects the operation if the instrument contains the record-ID field, which is useful guidance, but no direct comparison to sibling tools is made.

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 for behavioral disclosure. It states the core delete action and return value but omits critical context for a destructive operation: irreversibility, permissions required, or effects on dependent data. This is a significant gap for a delete 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 extremely concise, front-loaded with the primary action, and uses a clear Args/Returns structure with no wasted words.

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

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

For a simple one-parameter tool with an output schema, the description covers the basics, but it fails to mention permanent consequences or any caveats typically expected for deletion tools. This leaves the description functional but incomplete for safe use.

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 only provides the type (array of strings) and title, with zero description coverage. The description adds that these are 'record IDs to delete', providing minimal semantic meaning beyond the schema. This is adequate for a simple parameter but not richly compensating.

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

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

The description clearly states the action ('Delete records'), the target resource ('from the REDCap project by record ID'), and distinguishes it from sibling delete tools like delete_file and delete_instrument by specifying 'records'.

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 implicitly conveys when to use this tool (when deleting record-level data by ID) and the context distinguishes it from other delete operations, but it does not explicitly name alternatives or mention when not to use it.

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

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

No annotations are provided, so the description carries the burden. It discloses the default behavior ('None exports all arms') and the return format ('JSON array of arms with arm_num and name fields'), but does not explicitly state that the operation is read-only or side-effect-free, though 'export' implies 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 concise with clear Args and Returns sections, front-loading the purpose in the first sentence, and contains no superfluous 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 simple 1-parameter export tool with an output schema, the description covers the purpose, parameter behavior, return format, and project context ('longitudinal'), making it complete for agent selection and invocation.

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

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

The schema provides zero description coverage for the 'arms' parameter, but the description fully explains it: 'Specific arm numbers to export. None exports all arms.' This adds essential semantics beyond the schema's bare type definition.

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 'Export arms for a longitudinal REDCap project' with a specific verb and resource, clearly distinguishing from sibling tools like import_arms and delete_arms. The word 'arms' and 'export' make the action 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 retrieving arms but does not provide explicit guidance on when to choose this over sibling tools like export_events or import_arms. Context is clear but no exclusions or alternative mentions are given.

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 behavioral disclosure burden. It explains the default behavior when arms is None and specifies the return format. Though it doesn't explicitly state the operation is read-only, 'Export' strongly implies it. The description omits potential edge cases like invalid arm numbers, but the core behavior is 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 compact and well-structured, with a clear purpose sentence followed by Args and Returns sections. Every sentence serves a function, and the format is easy to scan.

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

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

For a tool with one optional parameter and an output schema, the description covers the essential aspects: what it does, how the parameter works, and what it returns. While it doesn't mention permissions or edge cases, the simplicity of the tool and the presence of an output schema make this 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 explanation of the arms parameter adds significant meaning beyond the schema's bare type and default. It clarifies that None exports all arms, fully compensating for the 0% schema description coverage.

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

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

The description states 'Export events for a longitudinal REDCap project' with a specific verb and resource, clearly distinguishing it from siblings like import_events and export_arms. The focus on events and export makes 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 provides context about longitudinal projects and the arms filter, implying when to use it, but it does not explicitly contrast with alternative tools such as import_events or export_arms. No exclusions or 'when not to use' guidance is provided, so usage is implied rather than explicitly directed.

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 the checkbox field name transformation with examples and specifies the return structure (JSON array of objects). It implies a safe read-only operation through 'export' and 'list', and provides solid behavioral context beyond the tool name.

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

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

The description is concise and well-structured with clear sections for purpose, details, Args, and Returns. Every sentence contributes meaningful information without redundancy.

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

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

For a simple one-parameter tool, the description is nearly complete: it covers purpose, usage, parameter, and return format. While it doesn't mention errors or behavior for non-checkbox fields, these are minor gaps given the tool's simplicity and the presence of an output schema.

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

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

The single parameter 'field' is fully described: 'Filter to a specific field name. None returns all fields.' This adds meaning absent from the schema (which has no property descriptions). The description effectively compensates for the 0% 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 identifies the tool's purpose: exporting a list of export field names for the project. It adds specific scope (project) and details about checkbox field naming conventions, which distinguishes it from sibling tools like export_records or get_metadata, though it doesn't name them explicitly.

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 explicit guidance on when to use the tool: 'Use this to resolve the correct names before exporting or referencing checkbox data.' It provides clear context but does not mention exclusions or alternative tools by name.

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 return format ('JSON object with base64-encoded file content, filename, and content type') and parameter context, which adds useful behavioral information. It does not explicitly confirm the operation is read-only, but the verb 'export' implies that.

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

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

The description is compact and well-structured: a one-sentence summary, a concise argument list, and a return value specification. Every line adds value, and the most critical information (purpose) is front-loaded. No unnecessary 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 description covers the tool's purpose, parameters, and return format. Since an output schema exists, the description does not need to detail return values further. It also covers the optional nature of event and repeat_instance with contextual notes, making it complete for this tool's complexity.

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

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

Schema description coverage is 0%, so the description must compensate. It provides explanations for all four parameters: record, field, event, and repeat_instance, going beyond the schema's type-only definitions. Each parameter gets a meaningful purpose statement, which is essential for correct usage.

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

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

The description clearly states a specific verb and resource: 'Export a file attachment from a REDCap record field.' It distinguishes itself from sibling tools like export_pdf or import_file by focusing on file upload fields, making it 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 clear context for when to use the tool, mentioning 'file upload field' and the optional event/repeat_instance parameters for longitudinal/repeating projects. However, it does not explicitly mention alternatives or exclusions, though the context is sufficient for most 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 the return type (JSON array of log entries) and the available filters, which effectively communicates non-destructive behavior. However, it does not explicitly mention permissions, rate limits, or data ordering.

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

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

The description is well-structured with a one-sentence summary followed by an Args and Returns section. Every line provides necessary information without redundancy or fluff.

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

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

All 5 optional parameters are described in detail, the return type is specified, and an example time format is provided. The tool's purpose and behavior are fully covered for an agent to use it correctly.

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

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

Schema description coverage is 0%, but the description compensates fully by explaining each parameter, including type, meaning, and allowed values (e.g., log_type enumerations and an ISO 8601 example for begin_time).

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 'Export the audit log for the REDCap project' with a specific verb and resource, distinguishing it from sibling export tools like export_records or export_report.

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 retrieving audit logs but does not explicitly state when to use it versus alternatives or provide any exclusions. The context is clear enough for basic selection, but no explicit guidance is given.

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 discloses the output format (base64-encoded PDF in JSON) and cautions about the all-records case. It does not explicitly state non-destructiveness, but the export verb implies it. This goes beyond a minimal description by adding relevant warnings and return type details.

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

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

The description is well-structured with a one-line summary, an Args section, and a Returns section. Every sentence serves a purpose, and the length is appropriate for five parameters. It is front-loaded with the core purpose and maintains readability.

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 5-parameter complexity and absence of annotations, the description covers all parameter semantics and the return format. It lacks explicit error handling or permission requirements, but for an export tool, it provides sufficient context for an AI agent to select and invoke it correctly.

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

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

Schema description coverage is 0%, so the description fully compensates by explaining each parameter's meaning and defaults. It clarifies that None for record and instrument means 'all', and that event is longitudinal-only. This adds significant value over the bare schema types.

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 a PDF of instruments for a record, distinguishing it from sibling tools like export_records or export_report. The verb 'Export' and specific resource 'PDF of instruments' make its 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 provides clear context on how to use the tool, including parameter-specific instructions like 'record: None exports all records (use with caution)' and 'event: Event name (longitudinal projects only)'. However, it does not explicitly contrast with alternatives or state when-not-to-use scenarios, so it stops short of a 5.

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

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

With no annotations, the description carries the full burden. It discloses important behaviors such as default limit of 1000, raw vs label value representations, checkbox label export behavior, and the JSON return format. However, it does not mention error handling, rate limits, or pagination beyond the limit.

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 efficiently structured with an Args section listing each parameter on its own line and a Returns section. Every sentence earns its place, providing necessary details without fluff or repetition.

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

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

The tool has 6 parameters and no annotations, but the description covers all parameters and return format. It is largely complete for selection and invocation. However, it does not differentiate from similar export tools (export_report, export_file) in the sibling list, which a complete description might address.

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

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

Schema description coverage is 0%, so the description fully compensates by explaining each parameter's purpose and special semantics (e.g., None exports all fields/records, events only for longitudinal projects, raw_or_label choices, checkbox label behavior). This adds significant value beyond the schema.

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

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

The description clearly states 'Export records from the REDCap project', using a specific verb and resource. It distinguishes from sibling tools like import_records and delete_records, and the return format is specified.

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 through parameter explanations and the export purpose, but it does not explicitly mention when to use this tool versus alternatives like export_report or export_file. No exclusions are stated, but the context is strong.

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 transparently mentions the version dependency, the error behavior on older instances, and the return format, including the empty-array case when no repeating instruments/events exist. This goes beyond a simple 'export' statement and provides useful operational context.

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

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

The description is three concise sentences, each delivering essential information: the action, a version caveat, and the return behavior. There is no redundant wording or padding, and the most important fact (what it exports) is 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?

For a simple stateless export with no parameters and an output schema, the description is sufficiently complete. It covers the expected output format, the empty case, and the version constraint. The existence of an output schema means the description does not need to enumerate return fields, and it adds the necessary nuance about older RedCap instances.

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 description coverage is 100% (vacuously). The description adds no parameter-specific meaning, but the baseline for zero parameters is 4, and there is no additional burden to compensate for undocumented 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 action ('Export') and the specific resource ('repeating instruments and events configuration'). The verb 'export' distinguishes it from the sibling 'import_repeating_instruments_events', and the resource is precise enough to differentiate it from other export tools like 'export_records' or 'export_arms'.

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 usage context by noting the REDCap version requirement and the error on older instances. However, it does not explicitly state when to use this tool instead of alternatives such as 'get_instrument_event_mappings', which may also relate to repeating instrument/event data. There is implicit guidance but no 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, the description carries the full burden. It discloses the return format (JSON array of report rows) and clarifies how to find the report_id, but it does not explicitly state that the operation is read-only or describe what happens for invalid IDs or permissions. This is partial disclosure but lacks deeper behavioral details.

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 extremely concise and well-structured with separate Args and Returns sections. Every sentence provides necessary information without redundancy, making it easy to parse and act on.

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

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

Given the tool's simplicity (one parameter, clear purpose) and the presence of an output schema, the description is largely complete. It covers the core function and the key parameter. The only gap is lack of explicit usage guidance relative to siblings, which is minor for such a straightforward tool.

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

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

The schema provides only the parameter name and type, with no description. The description compensates fully by explaining that report_id is the numeric ID visible in the REDCap URL, adding semantic meaning and a concrete way to obtain it. For a single parameter, this is thorough.

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 specific action ('Export a saved REDCap report') and identifies the resource by ID. It distinguishes this tool from siblings like export_records or export_file by targeting a saved report rather than raw data or files.

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 saved report ID, but it does not explicitly mention when to use this tool over alternatives or when not to use it. There is no reference to sibling export tools or exclusions, leaving the selection context partially unspecified.

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 full burden. It discloses error conditions and the requirement for surveys to be enabled, but does not state whether the operation is read-only or has side effects (e.g., creating a participant). This is a notable 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 structured into clear sections (Overview, Prerequisite, Args, Returns) with no filler. It efficiently conveys all necessary information 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 tool's simplicity and a schema that lacks descriptions, the description covers all critical aspects: purpose, parameter semantics, return type, and error conditions. The only missing piece is a clear statement about side effects or permissions, but overall it is highly 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 Args section provides a meaningful one-line description for each parameter, including 'Event name (longitudinal projects only)' and 'Repeat instance number (default 1)'. This compensates fully for the absent schema 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 opens with a specific verb phrase 'Get a unique survey link for a participant to complete an instrument', clearly identifying the tool's function and distinguishing it from sibling tools like export_survey_participant_list. It also mentions the prerequisite and error conditions, reinforcing the tool's 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?

It states a clear prerequisite ('instrument must be enabled as a survey') and describes error conditions when usage fails. However, it does not explicitly mention alternative tools or when not to use it, so it falls short of full 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 provided, the description carries the full burden. It discloses error behavior (returns error if surveys not enabled or instrument not a survey) and return format (JSON array). This adds behavioral context beyond the schema, though it could mention more about data fields included.

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

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

The description is well-structured with a clear main sentence, followed by preconditions, Args, and Returns sections. It is concise, front-loaded, and 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 moderately simple tool with 2 parameters and an output schema, the description covers purpose, preconditions, parameter semantics, and return format. It is complete enough for an agent 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?

Schema coverage is 0%, so the description's Args section is essential. It explains that 'instrument' is the internal name and 'event' is for longitudinal projects only, providing meaning beyond the bare schema. This is sufficient but could be slightly more detailed.

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 a list of survey participants for an instrument, using a specific verb and resource. It distinguishes from sibling tools like export_survey_link and export_records by focusing on participant list export.

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 on when the tool works (instrument must be enabled as a survey) and mentions error conditions for when it won't. It also specifies that the event parameter is for longitudinal projects only, which helps in selecting appropriate 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, the description carries the full burden. It discloses that the tool returns a valid, unused record ID respecting the auto-numbering scheme and notes the return type as a string. It doesn't clarify whether the ID is reserved upon generation, but the core behavior is well communicated.

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

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

The description is concise and well-structured, with the main purpose in the first sentence and a clear usage instruction and return statement following. Every sentence adds value without redundancy.

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

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

For a zero-parameter tool with an output schema, the description provides ample context: why to use it, when to use it, and what it returns. No important aspects are missing.

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

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

The tool has zero parameters, so the baseline score is 4. The description adds no parameter details, but none are needed since the schema is empty and coverage is trivially 100%.

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 ('Generate') and resource ('next record name'), which fully explains the tool's core function. It also distinguishes from sibling tools by specifying its role before importing a 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?

It explicitly says 'Use this before importing a new record' which gives clear context for when to use the tool. It doesn't mention alternatives or exclusions, but no direct alternative exists among the siblings, making the guidance sufficient.

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 that the tool returns a JSON array of mappings and an error message if the project is not longitudinal. This is useful behavioral context, though it does not explicitly confirm read-only behavior or other potential side effects, which is a minor 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 two sentences, with the core purpose in the first and return behavior in the second. Every sentence adds value, and it is appropriately sized for a simple no-parameter 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?

Given the tool's simplicity (zero parameters) and the existence of an output schema, the description is complete: it states the scope (longitudinal only) and the return type, and it notes the error condition. No critical information is missing for an agent to select and invoke this 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 tool has zero parameters, making parameter semantics trivial. The description correctly avoids inventing parameters, and the schema already fully covers the empty parameter set. The baseline of 4 is appropriate here.

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 ('Get') and resource ('mapping of instruments to events'), and clarifies it applies to 'longitudinal projects only'. This clearly distinguishes it from siblings like get_instruments or export_events, which focus on individual entities rather than mappings.

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 usage condition ('longitudinal projects only') and implies the tool is for retrieving mappings, not for modifying them. However, it does not explicitly mention alternative tools or scenarios where a different tool would be more appropriate, so it falls short of a perfect score.

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 present, so the description carries the full burden. It does disclose the return format (JSON array with internal names and display labels), which is a behavioral detail. However, it omits any statement about it being read-only, permission requirements, or edge-case behavior (e.g., empty project), leaving 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?

The description is two concise, well-structured sentences: the first states the purpose, the second specifies the return format. Every word earns its place, and the 'Returns:' label provides clear 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?

For a zero-parameter read-only listing tool, the description covers the essential function and output format. The presence of an output schema further reduces the need to explain return values. A brief mention of using get_metadata for field-level details would enhance completeness, but it's not a critical 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?

The tool has zero parameters, so the description is not responsible for explaining any. The baseline for no-parameter tools is 4, and the description correctly avoids adding unnecessary parameter details.

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 with a specific verb ('Get the list of instruments') and resource ('in the REDCap project'), including a parenthetical clarification that instruments are forms/surveys. It does not explicitly differentiate from sibling tools like get_metadata, which also provides project structure, so it misses the highest mark.

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 get_metadata or get_project_structure. The description merely states what it does without any contextual pointers, exclusions, or preferred 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 must carry the full behavioral disclosure burden. It discloses the JSON array return format and explains the filtering behavior of None meaning 'all'. However, it does not explicitly state that the operation is read-only or mention any permissions or side effects, leaving a notable 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 structured into clear sections: summary, parameter definitions, and return type. It is concise, with no filler or redundant content, and every sentence serves a purpose.

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

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

Given the tool's simple two-parameter interface and the presence of an output schema, the description covers the essential information an agent needs: purpose, parameters, defaults, and return format. It is sufficiently complete for correct tool selection and invocation.

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

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

The input schema has zero description coverage, so the description must explain the parameters entirely. It does so effectively by defining both 'fields' and 'forms' as filters, including the meaning of None (return all). This adds essential semantics beyond the bare schema types.

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

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

The description explicitly states it retrieves the data dictionary/metadata for the REDCap project, listing the specific field attributes returned. This clearly distinguishes it from sibling tools like get_instruments (which lists instrument names) or get_project_structure.

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

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

The description implies use when metadata is needed but offers no explicit guidance on when to prefer this tool over siblings such as export_field_names or get_project_structure. No exclusions or alternative tools are mentioned.

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

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

With no annotations, the description carries the full burden. It clearly indicates a read-only operation ('Get information') and specifies the return content, which conveys no side effects. It does not mention auth or rate limits, but for a simple metadata endpoint this is sufficient.

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

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

The description is short and front-loaded with the primary purpose. The final 'Returns:' block is redundant with the preceding sentence, slightly reducing conciseness, but the overall structure is clean and readable.

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

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

For a simple zero-parameter tool with an output schema, the description fully covers what the tool does and returns. There are no missing gaps in context, and the output schema handles the exact return structure.

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

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

The tool has zero parameters, so the schema is trivially complete (100% coverage). The description adds no parameter info, but the 0-param baseline of 4 applies, and no further explanation 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 clearly states the tool's purpose with a specific verb ('Get') and resource ('REDCap project'), and lists concrete information (title, PI name, etc.) that distinguishes it from sibling tools which operate on records, files, or instruments.

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 (getting project-level settings) but does not explicitly state when to use this tool over alternatives or provide exclusions. For a simple getter, this is adequate but lacks proactive 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 provided, the description carries the full burden. It clearly conveys that this is a read-only operation (repeated 'Return' statements) and explains the output structure (instruments, field counts, type breakdowns, event/instrument matrix). It stops short of stating edge cases like longitudinal vs non-longitudinal behavior explicitly, but the mention of 'for longitudinal projects' adds useful behavioral context. No contradictions.

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

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

The description is unusually efficient: three short paragraphs, each with a distinct purpose (overview, usage timing, output details). No word is wasted; the 'Returns:' line clearly signals the output type. It is front-loaded with the core purpose, making it easy for an agent to scan quickly.

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 no parameters and a straightforward output schema, the description is complete. It tells the agent what to expect (compact overview, instruments with counts and types, optional event matrix), when to use it (first call), and what form the output takes (JSON object). It does not over-explore because the output schema already exists, and sibling tools cover other concerns.

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

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

The tool has zero parameters, so the schema fully covers that aspect. Baseline for 0 params is 4. The description doesn't need to explain parameters and instead focuses on return semantics, which is appropriate.

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

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

The description opens with a specific action ('Return a compact structural overview') and clearly identifies the resource (REDCap project). It further distinguishes this tool from siblings by specifying exactly what it returns (instruments with field counts and type breakdowns, plus an event/instrument matrix for longitudinal projects), making it clear that this is not a full metadata or record dump.

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 says 'Useful as a first call when starting work on an existing project', providing clear when-to-use guidance. It does not mention alternatives or when-not-to-use, but the context of sibling tools (get_project_info, get_metadata, get_instruments) and the 'compact' nature imply it is a quick orientation tool, not a replacement for detailed 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 the full burden and discloses key behaviors: it creates or updates arms, and the override parameter explicitly states that existing arms not in the import will be deleted. This is a significant destructive behavior clearly disclosed. However, it doesn't explain how matching between existing and imported arms works (e.g., by arm_num), which is a minor 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 concise and well-structured: a one-sentence purpose statement followed by 'Args:' and 'Returns:' sections. Every sentence earns its place, and the most important information is 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?

For a two-parameter mutation tool with no annotations, the description covers data format, override behavior, and return value. The main missing piece is the upsert matching logic (e.g., by arm_num) and the default behavior when override is False. The output schema exists, so return value details are adequately addressed.

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

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

The input schema has zero description coverage and only provides titles 'Data' and 'Override.' The description fully compensates: it clarifies that 'data' is a JSON array of arm objects with arm_num and name fields, and explains 'override' as deleting existing arms not in the import. This is essential meaning absent from 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 states 'Import (create or update) arms in a longitudinal REDCap project.' This provides a specific verb (import), a clear resource (arms), and clarifies upsert behavior. It distinguishes from siblings like export_arms and delete_arms.

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

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

The description implies its usage through the verb and resource, but it does not explicitly mention when to use this tool vs alternatives. No exclusions or alternatives are named. The 'longitudinal REDCap project' context hints at a specific scenario, but explicit guidance is lacking.

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 discloses a key destructive behavior: 'If True, existing events not in the import will be deleted' for the override parameter. However, it doesn't mention other side effects like idempotency, impact on project structure, or potential irreversibility beyond the override.

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 follows a clear, conventional structure: summary line, Args section, and Returns section. Every sentence adds value with no redundancy or fluff.

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

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

For a tool with only two parameters and an output schema, the description covers purpose, both parameters, and return value adequately. It lacks mention of alternatives and doesn't enumerate all fields in the data array, but remains complete for the tool's complexity.

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

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

Schema description coverage is 0%, so the description is the only source for parameter meaning. It explains data as 'JSON array of event objects with event_name, arm_num, day_offset, etc.' and clarifies override's deletion behavior. However, the 'etc.' is vague and doesn't list all required fields or provide examples.

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

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

Description states 'Import (create or update) events in a longitudinal REDCap project' with a specific verb and resource, clearly identifying the tool's action. It distinguishes from siblings like export_events and delete_events by emphasizing the create/update nature, though it doesn't explicitly name alternatives.

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

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

The description gives no explicit guidance on when to use this tool versus alternatives such as export_events or delete_events, nor does it mention when not to use it. Usage is only implied by the verb 'import'.

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 provided, so the description carries full burden. It states the action and return (confirmation message) but does not disclose side effects such as overwriting existing files, permissions required, or error conditions. Missing key behavioral context beyond the obvious.

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?

Well-structured docstring: front-loaded purpose, concise parameter definitions, and a return statement. Every sentence adds value with no redundancy.

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

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

Covers parameters and return value sufficiently for a simple upload tool, but lacks guidance on when to use vs alternatives and does not mention potential side effects or failure modes. Completeness is adequate but has clear gaps.

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

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

Schema has no descriptions (0% coverage), but the description's Args section explains each of the 6 parameters, adding meaning beyond the schema titles. It clarifies event usage and repeat_instance, though it lacks detail on constraints like file size or encoding.

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?

Clear verb 'Import (upload)' with resource 'file' and target 'REDCap record field'. Distinct from sibling tools like delete_file and export_file, so 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?

No explicit when-to-use vs alternatives. The parameter hints (event for longitudinal projects, repeat_instance for repeating instruments) imply some usage constraints, but no exclusions or comparisons to sibling tools like import_records.

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

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

Annotations are absent, so the description must carry the transparency burden. It does disclose that data must be a JSON array string including the record ID field and that a confirmation with the count is returned. However, it omits critical behavioral details such as whether existing records are overwritten, whether validation occurs, or permission requirements.

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

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

The description is succinct, leading with a clear one-sentence purpose and using structured Args/Returns sections. Every sentence provides necessary information without redundancy.

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

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

For a simple tool with one parameter and an output schema, the description covers the main action, parameter format, and return value. It lacks details on side effects like overwriting and access requirements, but the overall description is reasonably complete for the tool's low complexity.

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 only the property name 'data' for the single parameter, but the description compensates fully by explaining that it is a JSON array string of records and that each record must include the project's record ID field. This adds meaningful semantics beyond the schema.

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

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

The description clearly states 'Import records into the REDCap project,' using a specific verb and resource. It distinguishes from sibling import_* tools by focusing on records, though it doesn't explicitly contrast with related tools like import_repeating_instruments_events.

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

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

There is no guidance on when to use this tool versus alternatives such as import_events, import_arms, or import_repeating_instruments_events. No exclusions, prerequisites, or preferred contexts are mentioned.

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

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

With no annotations, the description carries the burden. It states that it creates or updates, returns an error on older instances, and returns a confirmation message with a count. However, it does not disclose whether the operation replaces or merges existing configuration, or any permissions needed. This is acceptable but leaves 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 concise and well-structured, with a clear purpose statement, version note, Args, and Returns sections. Every sentence serves a purpose without unnecessary fluff, 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?

For a tool with a single parameter and no annotations, the description covers the operation, parameter format, return value, and an error condition. It lacks details on merge/replace semantics, but given the simplicity, it is reasonably complete. The presence of an output schema (though not shown) shifts some burden, but the description still provides essential 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 has 0% description coverage, so the description must compensate. It does this excellently by explaining that 'data' is a JSON array of objects with event_name, form_name, and custom_form_label fields, adding critical meaning beyond the bare schema definition.

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 imports (creates or updates) repeating instruments and events configuration, specifying the exact resource. This distinguishes it from sibling tools like import_records, import_events, import_arms, etc., by focusing on the 'repeating instruments and events' aspect.

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 includes a version requirement ('Requires REDCap 6.16 or later') which gives some usage context, but it does not explicitly state when to use this tool versus alternatives or provide exclusion criteria. The purpose implies usage for configuring repeating instruments, but no direct guidance is given.

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 behavioral traits. It does add context: moving fields affects data-entry screens, and setting after_field to None moves the field to the end of its instrument. However, it does not mention whether the operation is destructive, requires specific permissions, or has side effects on validation or surveys. This is partial 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 concise and well-structured: a introductory sentence, context, then Args and Returns sections. Each sentence earns its place, with no redundancy. The format is front-loaded and 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 tool's simplicity, the description is quite complete: it covers the operation, parameter behavior, and return value. However, it could be more comprehensive by addressing edge cases or prerequisites (e.g., whether the field must exist or if after_field must be in the same instrument). The existence of an output schema for the confirmation message helps, but a bit more behavioral context would make it 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 description provides detailed semantics for both parameters in the Args section: field_name is the variable name, and after_field specifies the immediate successor with None moving to the end. This fully compensates for the schema's 0% description coverage and is a strong example of parameter documentation.

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

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

The description clearly states the tool's function: 'Move a field to a new position in the data dictionary.' It uses a specific verb and resource, and the additional context about field order controlling layout reinforces the purpose. It distinguishes well from sibling tools like add_field, update_field, and remove_field.

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 explaining that field order controls layout, suggesting the tool is for reordering fields. However, it does not explicitly state when to use this tool versus alternatives like update_field for changing field properties or add_field for creating fields. There is no exclusion guidance, so it falls short of a higher score.

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 to lean on, the description carries the full burden. It explains the export/remove/import mechanism, warns about REDCap's rejection rules, and states the return behavior. This is solid, though it could mention irreversibility or referential integrity beyond branching logic.

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

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

The description is concise and well-organized: purpose, mechanism, caution, argument, return format. Every sentence earns its place, and the most important detail (what the tool does) is 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?

Given the tool's simplicity (one parameter, clear action) and the presence of an output schema in context signals, the description covers the essentials: action, mechanism, edge cases, and return value. It doesn't discuss auth or other errors, but those are not critical for a REDCap API wrapper with one field parameter.

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 only specifies field_name as a required string. The description adds semantic value by clarifying it is the 'Variable name of the field to remove,' which distinguishes it from a label. Schema coverage is 0%, so this compensation is necessary and well done.

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

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

The description opens with a specific verb and resource ('Remove a field from the project data dictionary'), clearly distinguishing it from sibling tools like add_field, update_field, and move_field. The scope and intent are unmistakable.

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

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

Usage is implied by the tool's name and description, but there is no explicit guidance on when to prefer this over alternatives (e.g., deactivating a field via update_field). It does provide cautionary notes about record-ID and branching logic, but stops short of positioning the tool relative to others.

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 all fields' form_name are updated, that the change is internal-only, and that a confirmation with count is returned. This is informative, though it does not mention reversibility or potential impacts on references.

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

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

Three short, focused sections with no filler—purpose, caveat, args/returns.

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 only two simple parameters and the description covers its purpose, parameter formats, side-effect limitation, and return value, making it fully sufficient for an agent to use correctly.

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

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

The schema lacks descriptions, but the Args section in the description defines both parameters, including the naming convention for new_form_name (lowercase, underscores, no spaces), adding significant meaning beyond the schema.

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

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

The description clearly states the action ('Rename an instrument') and the mechanism ('updating the form_name on all its fields'), distinguishing it from sibling tools like add_instrument or delete_instrument.

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 note about changing only the internal name while the display label must be updated separately provides clear context on when this tool is appropriate, but it does not explicitly reference alternatives.

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

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

No annotations are provided, so the description carries the burden. It discloses the return (confirmation or error if mapping didn't exist), but does not mention side effects, reversibility, permissions, or impact on existing data.

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 tightly scoped sections (action, args, returns) with no redundancy. It is front-loaded with the purpose and each sentence carries information.

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

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

For a simple 2-parameter mutation, the description covers the operation, parameters, and expected outcome. It lacks a suggestion to verify existing mappings via sibling tools, but is otherwise complete for the tool's complexity.

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

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

With 0% schema description coverage, the description fully compensates by defining 'Internal form name' for instrument and 'Unique event name' with an example, adding meaning far beyond the schema's bare property names.

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

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

The description uses a specific verb ('Remove') and resource ('instrument from an event'), and clarifies the longitudinal project context, distinguishing it from assign_instrument_to_event.

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 (removing an existing mapping), but no explicit alternatives or when-not-to-use guidance is provided. Sibling tools like get_instrument_event_mappings are not mentioned, nor is any prerequisite checking.

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 internal process of exporting the full dictionary, patching the target field, and importing it back, and states that only passed properties change. It also mentions the return behavior (confirmation or error if not found), which is valuable operational context.

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

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

The description is well-structured: opening purpose, behavior note, detailed arg list, and returns. It is somewhat verbose but necessary given 11 parameters. All content is relevant and front-loaded with the core purpose.

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

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

Given no annotations and a complex schema with 11 parameters, the description is fully complete. It covers all parameters, behavior, return values, and important caveats (preservation of unmentioned properties). 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 has 0% description coverage, but the description's Args section fully compensates with detailed explanations for all 11 parameters, including formats (e.g., choices formatted as "1, Label 1 | 2, Label 2") and semantics (e.g., required as boolean). This is well beyond what the schema provides.

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

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

The description clearly states the tool updates properties of an existing field in the data dictionary, distinguishing it from siblings like add_field, remove_field, and move_field. The verb 'update' plus the resource 'existing field in the data dictionary' precisely conveys 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 provides clear context that only passed properties are changed and all others are preserved, which is key when deciding to use this tool for partial updates. It implies the tool is for existing fields but does not explicitly name alternatives or when-not-to-use conditions, leaving some room for 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?

Despite no annotations, the description discloses key behavior: it checks every field's branching_logic for invalid [field_name] tokens, excludes event_name syntax in longitudinal projects, and returns either a confirmation or a JSON object with broken references. This is substantial transparency about what gets validated and what the output looks like.

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 efficiently structured: a one-line summary, followed by two detailed paragraphs explaining the check and the return value. No unnecessary words or repetition; every sentence contributes 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?

For a no-parameter validation tool with an output schema, the description fully covers behavior, exclusions, and return format. It provides all needed context for an agent to understand what the tool does without digging into structured data.

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% (vacuously). Per the rubric, 0 params gives a baseline of 4. The description appropriately adds no parameter details since none exist.

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

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

The description clearly states a specific verb and resource: 'Scan all branching logic expressions for references to non-existent fields.' It distinguishes itself from sibling tools like check_field_references by focusing solely on branching_logic expressions.

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 tool's purpose implies when to use it (to validate branching logic references), but it does not explicitly mention alternatives, exclusions, or when not to use it. There's no guidance on how it differs from similar validation tools like check_field_references.

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