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

Annotations already declare readOnlyHint=true, destructiveHint=false, idempotentHint=true, openWorldHint=true, covering the safety and idempotency. The description adds 'optionally filtered' but does not elaborate on return format or behavior beyond what annotations provide. With strong annotations, the description's added value is minimal.

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

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

The description is a single, complete sentence that front-loads the purpose. Every word earns its place with no extraneous 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?

No output schema exists, yet the description does not specify the return format (e.g., a single number). With 12 optional parameters and no guidance on their interaction, the description is incomplete for an agent to fully understand the tool's behavior without additional inference.

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

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

Input schema has 100% coverage with descriptions for all 12 parameters. The description only highlights 'collection or type' filters, not adding meaning beyond schema. Baseline is 3 for high schema coverage; description does not compensate for low coverage (which is not the case).

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 'Get' and resource 'total count of actions', directly specifying the tool's function. It distinguishes from sibling tools like transkribus_action_list (returns list) and transkribus_action_info (returns info) by focusing on a count.

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 mentions optional filtering but provides no explicit guidance on when to use this tool versus alternatives. It does not indicate when not to use it or direct the agent to other tools for more detailed queries, leaving the agent to infer usage context.

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

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

Annotations already declare readOnlyHint=true, destructiveHint=false, idempotentHint=true, and openWorldHint=true. The description does not add any behavioral context beyond the annotations, but it does not contradict them either.

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

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

The description is a single, clear sentence with no unnecessary words. It is front-loaded with the action verb and resource.

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

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

Given the tool has no output schema, the description does not elaborate on what 'detailed information' includes. While annotations provide safety and idempotency hints, the description could be more complete by listing typical response fields. However, it is adequate for a simple retrieval tool.

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

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

Schema coverage is 100% for the single parameter 'id', which is described in the schema as 'Resource ID'. The description does not add any further meaning or constraints to the parameter.

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 'Retrieve' and the resource 'detailed information about a specific action'. It distinguishes from sibling tools like transkribus_action_list (which lists actions) and transkribus_action_count (which counts actions) by specifying 'specific action' via an ID.

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

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

The description implies usage when you need details of a single action, but does not provide explicit when-to-use or when-not-to-use guidance. No prerequisites or alternatives are mentioned.

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

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

Annotations already declare readOnlyHint=true, destructiveHint=false, and idempotentHint=true, so the description adds minimal behavioral context beyond stating optional filtering. It does not describe the response format, pagination behavior, or any side effects, but annotations cover the safety profile.

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

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

The description is a single sentence of 12 words, extremely concise. It is front-loaded with the core action and filtering options. While concise, it could be more structured by separating pagination detail, but there is no wasted content.

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

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

Given the tool has 17 parameters, no output schema, and no explicit return value description, the description is too minimal. It does not explain the meaning of 'actions', the response structure, or pagination behavior. Sibling tools exist but no guidance is provided. The description leaves significant gaps for an agent.

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

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

Schema coverage is 100% (all 17 parameters have descriptions). The description mentions filtering by collection, type, and pagination, which maps to a subset of parameters, but does not explain pagination-related parameters like index, nValues, sortColumn, etc. Baseline 3 is appropriate as the schema already provides 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 lists actions with optional filtering, using a specific verb 'List' and resource 'actions'. However, it does not differentiate from sibling tools like transkribus_action_count or transkribus_action_info, which perform related but different tasks.

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. It does not mention when not to use it or any prerequisites. The agent must infer usage from the name and schema.

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

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

Annotations already declare readOnlyHint=false, idempotentHint=false, destructiveHint=false, and openWorldHint=true, so the safety profile is covered. The description adds only the scoping phrase 'to run a job implementation' and says nothing about whether it appends to or replaces the existing ACL, or that repeated calls (non-idempotent) may duplicate grants.

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

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

A single front-loaded sentence with no filler, which is structurally clean. It is arguably too sparse for an admin mutation tool, but there is no wasted language.

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 admin mutation with full schema coverage and no output schema, the description is minimally adequate. It omits key behavioral context about ACL semantics and permissions, but the annotations carry the safety profile.

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

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

Schema description coverage is 100%, with both jobImpl and userIds clearly documented in the schema, so the baseline of 3 applies. The description's 'specific users' and 'job implementation' merely restate what the schema already conveys, adding no format or constraint detail.

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 (Authorize) and resources (specific users, job implementation), which is more precise than the bare title. It does not, however, differentiate itself from related siblings such as transkribus_user_is_allowed_for_job, transkribus_admin_get_job_users, or transkribus_user_get_job_acl.

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 statement of when to use this tool versus checking whether a user is already allowed (transkribus_user_is_allowed_for_job) or listing current job users (transkribus_admin_get_job_users). Prerequisites such as requiring admin rights are also absent, leaving usage entirely to inference.

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

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

The annotations already declare readOnlyHint=true, destructiveHint=false, idempotentHint=true, and openWorldHint=true, so the agent knows it is a safe, non-destructive read. The description adds minimal extra behavioral context beyond confirming it retrieves log output. 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 a single, well-structured sentence that is front-loaded and concise. Every word earns its place, though it is very brief.

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 number of sibling tools and the lack of an output schema, the description is too minimal. It does not explain the content of the log output, expected format, or any constraints (e.g., job must exist), leaving the agent with insufficient information to fully understand the tool's 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 100% with clear field descriptions ('Resource ID', 'Database identifier'). The description does not add any additional meaning to the parameters, so a baseline of 3 is appropriate.

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

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

The description clearly states the verb 'Retrieve' and the resource 'log output for a specific job', making the purpose evident. It is distinct from sibling tools like transkribus_job_get (which gets job details) and transkribus_job_get_errors (which gets errors), though it does not explicitly differentiate itself.

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 such as transkribus_job_get or transkribus_job_list. It lacks context about prerequisites, job state, or 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?

Annotations already declare readOnly, idempotent, non-destructive. Description adds context that it lists authorized users for a specific job implementation, reinforcing safe behavior without contradiction.

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

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

Single sentence, no wasted words. Could be slightly more detailed but adequate 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?

Tool has one parameter, no output schema. Description sufficiently covers purpose and required input. Complete enough for its 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 has 100% coverage with description for jobImpl. Description adds no extra meaning beyond schema. Baseline 3.

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

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

Description clearly states verb 'List', resource 'users authorized', and context 'for a specific job implementation'. It distinguishes from siblings like transkribus_admin_authorize_users_for_job.

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?

Description implies usage (when needing authorized users for a job implementation) but does not explicitly state when to use or avoid, nor mention alternatives.

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

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

Annotations already declare readOnlyHint, idempotentHint, and destructiveHint, making the behavior clear. The description adds no additional behavioral context (e.g., format, pagination, or authorization needs). It does not contradict annotations.

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

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

The description is a single, efficient sentence of 8 words that immediately conveys the tool's purpose. It is front-loaded and free of unnecessary verbiage.

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 (2 string params, no output schema, comprehensive annotations), the description lacks essential details about acceptable report types, time period formats, and the structure of returned data. The agent would benefit from examples or references to documentation.

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

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

Schema coverage is 100%, so both parameters are documented in the input schema. The description merely echoes the parameter names ('type and time period') without adding semantic details beyond the schema's minimal descriptions. It meets the baseline but adds no extra value.

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 'retrieve' and resource 'administrative reports', specifying the key dimensions 'by type and time period'. It effectively differentiates from sibling tools like transkribus_admin_get_job_log or transkribus_stat_get_coll, though it does not explicitly mention 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?

No usage guidelines are provided. The description does not indicate when to use this tool over other administrative or statistics tools, nor does it mention prerequisites like admin permissions or specific report types available.

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

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

Annotations already declare readOnlyHint=true and idempotentHint=true, so the description adds some context ('active') but does not go beyond what annotations imply.

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

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

The description is a single, clear sentence with no extraneous words, achieving maximum conciseness.

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?

While the purpose is clear, the description lacks details on the output format or any prerequisites, but given the tool's simplicity and rich annotations, it is minimally 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?

No parameters exist, and schema coverage is 100%, so description is not required to add parameter info; baseline 4 applies.

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

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

The description clearly states it lists all currently active user sessions, which is specific and distinct from sibling admin tools like transkribus_admin_authorize_users_for_job or transkribus_admin_get_job_log.

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

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

The description does not provide explicit guidance on when to use this tool versus alternatives, but its purpose is straightforward for listing active sessions, so usage is implied.

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

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

Annotations already indicate idempotency and non-destructive behavior. The description adds no extra behavioral context beyond 'move', which is consistent but doesn't disclose details like directory creation behavior.

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

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

The description is a single concise sentence that quickly conveys the core function. It is front-loaded but could be slightly more informative.

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

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

Given the tool has only 2 parameters and no output schema, the description covers the basic purpose. However, it omits details like whether the target directory must exist or if the operation is reversible.

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

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

Schema coverage is 100%, with both parameters described adequately. The description adds no additional meaning beyond what the schema already provides.

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

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

The description clearly states the verb 'Move' and the resource 'field recognition model' to a 'different directory'. It effectively distinguishes from siblings like transkribus_admin_move_table_model.

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, such as prerequisites for the target directory or when not to move a model.

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

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

Annotations already indicate idempotent and non-destructive behavior. The description adds no additional behavioral traits, such as the effect on model references or if moving deletes the original. It does not contradict annotations.

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

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

The description is a single, efficient sentence of 11 words with no redundancy. It conveys the essential information without unnecessary detail.

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

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

For a simple move operation with two parameters and good annotations, the description provides the core action. However, it does not specify whether the path is relative or absolute, or error handling for non-existent models, which would enhance completeness.

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

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

Both parameters have clear descriptions in the schema ('Table model name to move' and 'Target directory path'). The description adds no extra meaning beyond what the schema provides, so baseline score of 3 is appropriate.

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

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

The description clearly states the specific action (move), resource (table recognition model), and destination (different directory). It effectively distinguishes from the sibling tool 'transkribus_admin_move_field_model' by specifying the model 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 explicit guidance on when to use this tool versus alternatives, or prerequisites. The description implies usage when a table model needs moving, but lacks context like when not to use it or comparison to similar move tools.

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

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

Annotations provide limited info (destructiveHint=false), but 'rebuild' implies potential overwriting; description adds no behavioral traits like side effects, duration, or admin 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?

Single sentence that is front-loaded and concise, with zero 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?

Minimal but adequate for a simple admin action. Lacks details on prerequisites, whether it triggers a background job, or impact on existing indices.

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?

No parameters exist, and description correctly implies no input needed. Baseline 4 for zero-param tools, and no additional info required.

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 the verb (rebuild), resource (search index), and scope (for all recognition models), providing clear purpose. It distinguishes from sibling tools like transkribus_search_reset_index by specifying models.

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

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

No guidance on when to use this tool, prerequisites, or alternatives. The description lacks context like 'use after model updates' or comparisons to similar tools.

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

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

Annotations already declare readOnlyHint, idempotentHint, and destructiveHint=false, so the read-only, side-effect-free profile is covered. The description adds no behavioral detail beyond stating the validity check, but it does not contradict the annotations.

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

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

The description is a single sentence, front-loaded with the verb and object, and contains no filler. It is appropriately sized for a zero-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 absence of parameters, rich safety annotations, and low complexity, the description is essentially complete for invoking the tool. It does not specify the exact return type of the validity check, but that is a minor gap for such a simple 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?

This tool has zero parameters and schema coverage is 100%, so there is nothing for the description to add about inputs. The baseline of 4 for parameterless tools 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 ('Check') and a clear resource ('current Transkribus session') with an explicit outcome ('is valid'). It is distinguishable from sibling auth tools like auth_refresh and auth_get_details by the validity focus, though it does not explicitly name these 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?

There is no guidance on when to use this tool instead of auth_get_details, auth_refresh, or auth_logout, and no mention of using it as a precondition for other operations. Any usage context is only implicit in the name and short description.

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

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

Annotations already declare readOnlyHint, idempotentHint, openWorldHint, and destructiveHint=false, so the safety profile is covered. The description adds no additional behavioral context such as auth requirements or output variability, but it is consistent with the annotations.

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

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

A single clear sentence fully conveys the tool's function with no filler or redundant restatement of the name.

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

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

For a zero-parameter, read-only tool, basic invocation is straightforward. However, there is no output schema and the description says only 'details' without indicating what user fields are returned, leaving some ambiguity about the tool's output.

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 schema description coverage is 100%, so there is no parameter information for the description to supplement. Baseline 4 is appropriate.

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

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

The description uses a specific verb ('Get') and an unambiguous resource ('details of the currently authenticated user'). This clearly distinguishes it from sibling auth tools like transkribus_auth_check_session, transkribus_auth_invalidate, transkribus_auth_logout, and transkribus_auth_refresh, which concern session lifecycle rather than user details.

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 when-to-use guidance, exclusions, or alternatives. It does not mention when to prefer this over transkribus_auth_check_session (for session status) or transkribus_user_get (for other user lookups).

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

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

Annotations already signal destructiveHint=true and readOnlyHint=false, and the description adds that the affected resource is the current authentication session. It does not disclose downstream effects such as requiring re-authentication or whether all sessions are affected, but it does not contradict the annotations.

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

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

The description is a single, front-loaded sentence with no filler. Every word contributes to the meaning, making it highly concise and 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 zero-parameter destructive auth action, the description plus annotations make the tool callable, but it omits useful context such as the effect on subsequent authenticated requests and the relationship to logout/refresh siblings. The absence of an output schema or explicit behavioral context leaves some ambiguity about the real-world impact.

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 parameters and 100% schema description coverage, so there is no parameter documentation gap. The baseline for a zero-parameter tool is 4, and the description does not need to compensate for missing parameter semantics.

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

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

The description clearly identifies the action ('invalidate') and the resource ('current authentication session'), so an agent can tell what the tool does. However, it does not distinguish it from the similarly scoped sibling transkribus_auth_logout, so it falls short of full sibling differentiation.

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 instead of alternatives such as transkribus_auth_logout or transkribus_auth_refresh, nor any warning about when not to call it. The description only states the operation without usage context.

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

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

Annotations already indicate the operation is idempotent and non-destructive. The description adds the useful scoping cue 'current Transkribus session', but it does not mention post-logout effects such as invalidating the token or requiring re-authentication.

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

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

One concise, front-loaded sentence with no filler or redundancy. It fully communicates the tool's action in minimal space.

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, idempotent authentication action, the description plus annotations provide enough to invoke the tool correctly. It lacks explicit post-conditions and sibling-routing details, but the simplicity of the operation keeps the gap modest.

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 properties and schema description coverage is 100%, so there are no parameters requiring documentation. The description needs no parameter-level detail.

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 a specific verb ('Log out') and resource ('current Transkribus session'), making the purpose clear. It is easily distinguished from check_session and get_details, but it does not explicitly differentiate from auth_invalidate, which may be a nearby alternative.

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

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

No guidance is given about when to use logout versus auth_invalidate, auth_refresh, or check_session. The description simply restates the action without providing selection criteria or exclusions.

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

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

Annotations already indicate idempotentHint=true and destructiveHint=false, so the agent knows the operation is non-destructive and safe to repeat. The description adds no behavioral context beyond naming the resource, e.g., no mention of side effects on the existing token or behavior if the session is invalid. It does not contradict annotations.

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

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

The description is a single, direct sentence with no filler. It is front-loaded with the action and names the target resource immediately. Every word earns its place.

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

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

For a zero-parameter, no-output-schema tool with annotations covering safety, the description is nearly complete. It states the action and target. It could mention the effect (e.g., extends token validity) or note a prerequisite that an authenticated session exists, but these are minor gaps for such a simple 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 tool has zero parameters and the schema is an empty object, so the baseline is 4. The description need not explain parameters. The phrase 'current authentication session token' implicitly clarifies that no parameters are needed because the session is identified by the existing token.

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 ('refresh') and a clear resource (current authentication session token). It is distinct from sibling auth tools like check_session, get_details, invalidate, and logout, so an agent can distinguish it. It does not restate the title alone; it specifies exactly what is refreshed.

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 the current authentication session token needs refreshing. However, it does not explicitly mention when to use it compared to alternatives (e.g., auth_check_session, auth_logout) or state any prerequisites or exclusions. The context is clear enough for a trivial zero-parameter operation, but no guidance is provided.

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

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

Annotations already declare readOnlyHint=true and idempotentHint=true, so the description's claim of 'Get' is consistent. However, the description adds no extra behavior details beyond what annotations and schema imply.

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?

Single sentence is concise and front-loaded. However, it could include more detail without sacrificing brevity.

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 output schema and many sibling tools, the description lacks an explanation of what constitutes 'recognition activity' or the return format. Adequate for a simple read, but incomplete for full understanding.

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

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

Schema description coverage is 100%, so parameters are self-explanatory. Description adds no additional semantics about parameter usage or format.

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 clearly states the action (Get), resource (recognition activity records), and scope (for a collection), distinguishing it from siblings like transkribus_user_activity_recognition and transkribus_coll_activity_saves.

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

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

No guidance on when to use this tool versus alternative activity tools such as transkribus_coll_activity_saves. The description does not provide context for selection.

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

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

Annotations already indicate readOnlyHint=true, destructiveHint=false, idempotentHint=true. The description adds no behavioral context beyond the name, but does not contradict annotations. With annotations, minimal extra information is acceptable.

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?

Single sentence, no wasted words. While minimal, it effectively states the tool's purpose. Could benefit from a bit more detail, but remains concise.

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

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

For a simple read tool with three parameters and no output schema, the description is adequate but lacks explanation of what 'save activity' includes (e.g., types of saves, timestamps). Annotations cover safety, but completeness could be improved.

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

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

Schema coverage is 100% with descriptions for all three parameters (collId, from, to). The description does not add further meaning, such as the relationship between from/to or default behavior. Baseline 3 is appropriate given high schema coverage.

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

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

Description clearly states 'Get save activity records for a collection' with a specific verb and resource. However, it does not differentiate from sibling tools like transkribus_user_activity_saves or transkribus_coll_activity_recognition, which could lead to confusion.

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

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

No guidance on when to use this tool versus alternatives. Lacks context about prerequisites, such as requiring a valid collId, or when to choose this over other activity-related tools.

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

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

Annotations already declare readOnlyHint=false, openWorldHint=true, idempotentHint=false, and destructiveHint=false, which covers the basic safety profile. The description adds little behavioral context beyond what the annotations and title already imply; it does not mention copy-versus-move behavior, permissions, or duplicate handling. It is consistent with the annotations, so there is no contradiction.

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

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

The description is a single, front-loaded sentence with no filler or redundancy. It communicates the core operation efficiently. It is concise without being a bare tautology.

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 mutation with two required integer IDs and one optional flag, the schema and annotations are mostly sufficient for invoking the tool. However, the description omits any note about return values, duplicate membership behavior, or the copy-versus-move default, and no output schema exists to fill that gap. A bit more context would make it more complete.

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

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

Schema description coverage is 100%, so the baseline is 3. The description adds slight meaning by emphasizing that the document must already exist, but it does not clarify the relationship between the optional 'id' and required 'docId', nor does it explain the moveTo semantics beyond what the schema already states.

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

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

The description clearly states a specific action: add an existing document to a collection. The verb 'add' and the resources 'document' and 'collection' are clear, and 'existing' distinguishes this from creation or upload tools. However, it does not explicitly distinguish itself from the similarly named sibling transkribus_coll_add_docs, so it stops short of a 5.

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

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

No guidance is provided on when to use this tool versus alternatives. It does not mention sibling tools such as transkribus_coll_add_docs for adding multiple documents, transkribus_coll_remove_doc for removal, or the various document creation/upload tools. The agent is left to infer usage from the tool name and schema.

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

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

Annotations already signal a non-read-only, non-idempotent, open-world operation; the description does not contradict them. It adds no extra detail about side effects such as duplicate behavior, permissions, or whether moveTo changes the operation, so it stays at baseline.

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?

Single sentence, front-loaded with the verb and object, no filler. Every word earns its place for such a simple tool.

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

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

Adequate for a straightforward bulk-add call because all parameters are documented and the purpose is unambiguous. However, with no output schema and no guidance on duplicates, preconditions, or failure behavior, an agent has to infer those from the API context.

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

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

Schema coverage is 100%, so the schema already documents collId, docIds, and moveTo clearly. The description adds no parameter-specific meaning beyond the schema, so baseline 3 is appropriate.

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

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

The description uses a specific verb ('add'), a clear resource ('existing documents'), and a target ('collection'). The plural 'multiple' signals this is the bulk variant of transkribus_coll_add_doc, distinguishing it without extra wording.

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

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

It clearly states the operation is for multiple existing documents, which implies use when batching additions. It does not explicitly name the singular alternative transkribus_coll_add_doc or state when not to use this tool, but the context signal is strong enough.

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 (readOnlyHint=false, idempotentHint=false) already signal a mutating, non-idepotent operation, but the description adds no behavioral context beyond that. It does not disclose whether re-adding an already-favored collection fails or silently succeeds, what happens if the collection does not exist, or whether the favorite is per-user. No contradiction with annotations, but no added value either.

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

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

The description is a single, front-loaded sentence with no wasted words. It borders on redundancy with the tool name and title, but it remains an efficient and complete sentence rather than a tatuological stub.

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 fully documented parameter and no output schema, all required calling informtion is present: what the tool does and what to pass. However, it omits useful context such as the existance of the inverse sibling for removal, repeat-call behavior, and user scopcing of favorites, which would help an agent 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 100%, so collId is already documented as 'Collection ID' in the schema. The description merely echoes 'collection' without adding extra meaning or constraints beyond what the schema provides, matching the baseline for fully documented parameters.

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

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

The description states a specific action ('Add') and a clear resource ('collection' to 'user favorites'), making the core operation unambiguous. However, it does not explicitly distinguish itself from siblings, particularly the inverse transkribus_coll_remove_favorte, leaving the differentiation to the tool name and title.

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 offers no guidance on when to use this tool versus its alternatives. It does not mention the inverse operation transkribus_coll_remove_favorte, nor any conditions or prerequisites (e.g., ownership, authentication, or whether favorites are user-scoped).

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

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

Annotations already declare readOnlyHint=true, idempotentHint=true, and destructiveHint=false, so the safety profile is covered. The description adds the 'current user' scope, but does not disclose anything else about behavior such as return shape, error conditions, or authentication requirements.

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

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

The description is a single, front-loaded, concise sentence that directly states the operation. Every word contributes meaning and there is no redundant or filler content.

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

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

This is a simple single-parameter, read-only permission check with strong annotations and no output schema. The description is adequate for an agent to understand the tool, though it leaves the boolean result implicit rather than stating it explicitly.

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

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

Schema description coverage is 100%, with collId described as 'Collection ID'. The description adds no additional parameter semantics beyond confirming the collection is the target of the check, so the baseline of 3 applies.

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

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

The description states a clear verb ('Check if') and a specific resource ('the current user can manage the specified collection'), so an agent can understand the tool's purpose. It does not explicitly distinguish itself from sibling permission-related tools such as transkribus_auth_check_session or transkribus_coll_user_stats, but the intent is unambiguous.

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

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

The description gives no guidance on when to use this tool versus alternatives, nor does it mention prerequisites or exclusions. There is only an implicit sense that it should be used to verify management permission before performing collection-managing actions.

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

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

Annotations already declare readOnlyHint, idempotentHint, and destructiveHint=false, so the safety profile is covered. The description adds that the count is scoped to collections accessible to the current user, but does not disclose details like whether empty collections are counted by default or how the filter affects results.

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

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

A single sentence that front-loads the operation, resource, and scope with no wasted words. It is exactly as long as needed 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 read-only count tool with annotated safety and fully described parameters, the description is mostly complete. It states the result domain ('total number') and the scope, but with no output schema it leaves the exact response representation unstated, which is a minor gap.

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

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

Schema description coverage is 100%, so both parameters are already documented in the input schema. The description adds no extra meaning about the parameters, and the schema's 'Filter string' is terse, but the description does not need to compensate for a coverage gap.

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

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

States a specific operation ('get the total number') on a specific resource ('collections') and defines the scope ('accessible to the current user'). It is immediately distinguishable from sibling count tools like coll_count_docs and coll_count_find_documents by naming collections as the counted entity.

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

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

The description clearly implies this tool is for obtaining a count rather than a list or detailed collection data. It does not explicitly name alternatives or state when not to use it, but the context is clear and the scope is well-defined.

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

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

Annotations already declare readOnlyHint=true, openWorldHint=true, idempotentHint=true, and destructiveHint=false, covering the safety profile. The description adds no extra behavioral context, such as how filters like labelId or isDeleted affect the count. It does not contradict annotations, but it provides minimal additional transparency beyond what the annotations already convey.

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

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

The description is a single sentence with no filler words. It immediately conveys the purpose and is perfectly structured for quick comprehension.

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

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

Given the simplicity of the tool (counting documents), the description is adequately complete. The schema explains all filters, annotations cover safety, and the description implies a numeric return value. No critical information is missing for an agent to call the tool correctly.

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

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

Schema description coverage is 100%: each parameter has a description ('Collection ID', 'Filter by label ID', 'Include deleted documents', 'Filter by uploader ID'). The description adds nothing beyond the schema, so the baseline of 3 applies.

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

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

The description states a clear action: 'Get the number of documents in a collection.' It specifies the verb (get), the resource (collection), and the result (count). It does not explicitly distinguish from siblings like transkribus_coll_count or transkribus_coll_count_find_documents, but the scope 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 guidance is provided on when to use this tool versus alternatives such as transkribus_coll_count_find_documents (which likely supports more complex filters) or transkribus_coll_list_docs (which returns documents rather than just a count). The description gives no context for selection.

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

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

Annotations already declare readOnlyHint=true, idempotentHint=true, and destructiveHint=false, so the safety profile is fully covered and the bar for the description is lower. The description adds no behavioral context beyond restating the operation — no mention of result bounding, the open-world scope implied by openWorldHint, or what the count represents. This is acceptable but adds no value on top of annotations.

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

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

The description is a single front-loaded sentence with zero wasted words — the verb and object appear immediately. It is appropriately brief for a count operation, though it errs on the side of brevity given the 13-parameter search surface it governs.

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 13 filter parameters, no required arguments, and no output schema, the description is thin: it does not state the return shape, whether the count is bounded, or how this differs from the find_documents variants among siblings. The 100% schema coverage and safety annotations partially compensate, making this minimally viable but not complete.

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

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

Schema description coverage is 100%, so every one of the 13 filter parameters is already documented with a description; the baseline of 3 applies. The description's phrase 'search criteria' broadly groups the parameters but adds no combinatorial semantics, such as how filters combine or the effect of defaults like isDeleted and exactMatch.

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

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

States a specific verb ('Count') plus resource ('documents') and the scoping mechanism ('matching the given search criteria'), which inherently distinguishes it from transkribus_coll_find_documents (returns the documents) and transkribus_coll_count_docs (counts within a single collection). However, the differentiation is implicit in the word 'Count' rather than explicit, and no sibling is named.

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?

Provides no guidance on when to choose this over the adjacent family: transkribus_coll_find_documents, transkribus_coll_find_documents_post, and transkribus_coll_count_docs are all plausible alternatives an agent could confuse it with. No exclusions, prerequisites, or decision context are given — the single sentence simply restates the operation.

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

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

Annotations already indicate a mutating, non-idempotent, non-destructive operation. The description adds no additional behavioral context such as duplicate-name handling, permission requirements, or side effects beyond the obvious 'create' action.

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

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

The description is a single clear sentence with no filler, and the key action is front-loaded. Nothing extraneous is present.

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

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

This is a simple one-parameter creation tool, and annotations plus schema cover the core safety and input requirements. However, the description does not mention return behavior, duplicate-name outcomes, or any other post-creation expectation, leaving some practical 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?

The input schema already documents collName with its own description, and schema coverage is 100%. The description only restates the idea of 'the given name' and adds no extra meaning about format, uniqueness, or validation.

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 and resource: create a new collection. This is distinguishable at a high level from the many sibling document/page creation tools, though it does not explicitly call out any sibling distinction.

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 about when to use this tool versus alternatives such as creating a document, adding a document to a collection, or importing from METS/PDF/IIIF. The agent must infer usage entirely from the tool name and description.

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

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

Annotations already declare readOnlyHint=false, openWorldHint=true, idempotentHint=false, and destructiveHint=false, so the safety profile is covered. The description adds little beyond that: it says 'ingest a document into a collection from an FTP source,' which mostly restates the name and title, with no extra detail about authentication, FTP path handling, or side effects beyond the schema's parameters.

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

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

One short sentence with the action and source front-loaded, no filler, and no redundant clauses. It is appropriately sized for the description's limited scope.

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

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

The description is adequate given 100% schema coverage and existing annotations, but it is thin for a tool with many closely related import siblings. It does not explain when to choose this FTP variant over other create_doc_from_* tools, nor does it mention any FTP-specific prerequisites.

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

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

Schema description coverage is 100%, so all four parameters are already documented in the schema. The description adds no additional parameter meaning, so the baseline of 3 applies when the schema does the heavy lifting.

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

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

States a specific verb ('ingest') and resource ('document into a collection') along with a source type ('FTP'). This distinguishes it from siblings such as transkribus_coll_create_doc_from_iiif and transkribus_coll_create_doc_from_mets, though it does not explicitly name an alternative.

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

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

The phrase 'from an FTP source' implies the usage context: use this tool when importing from FTP. However, it gives no explicit when-to-use/when-not-to-use guidance and does not compare against sibling import tools like add_doc or create_doc_from_mets.

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

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

Annotations already cover safety (readOnlyHint=false, destructiveHint=false, idempotentHint=false, openWorldHint=true), so the bar is lower, but the description adds nothing beyond restating the operation. It does not say the tool fetches an external manifest, whether the resulting document contains pages, or whether repeated calls create duplicates (notably relevant given idempotentHint=false).

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

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

A single front-loaded sentence with no filler or redundancy. It is efficient, though its brevity is partly the source of the missing usage and behavior detail.

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

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

For a non-idempotent, open-world creation tool with no output schema, the description leaves the agent without the returned identifier, any indication of whether the imported manifest is fetched synchronously, or permission/collection-membership prerequisites. The schema covers inputs, but key behavioral expectations 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?

Schema description coverage is 100% and all three parameters (url, collId, canvasFilenameReference) are documented in the schema. The description adds no extra meaning, such as URL format requirements or what the optional canvasFilenameReference does, so baseline 3 applies.

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

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

States a specific verb (Create), resource (document), container (in a collection) and source (IIIF manifest URL). The IIIF qualifier implicitly distinguishes it from siblings such as transkribus_coll_create_doc_from_mets, _from_mets_url and _from_ftp, though no sibling is named 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?

There is no explicit when-to-use guidance or exclusion criteria. An agent must infer from the name that this is the IIIF variant versus the METS/FTP siblings; the description never says to prefer this tool when the source is an IIIF manifest rather than another import format.

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

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

Annotations already declare this is a non-readonly, open-world, non-idempotent, non-destructive write. The description adds useful context (multipart upload, exactly-one-source constraint) but says nothing about permissions required, cost implications, or side effects of repeated calls.

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

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

Two sentences, no waste, with the core action front-loaded and the input constraint immediately following. Every clause earns its place.

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

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

The absence of an output schema means the description could usefully say what a successful call returns (e.g., document ID), and it omits prerequisites like collection permission. Adequate for invoking the tool but not fully complete for a creation 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?

Schema coverage is 100%, so field meanings are covered, but the description adds the mutual-exclusivity rule ('exactly one of metsXml or metsFilePath') that the schema does not encode via anyOf/oneOf. That is genuine semantic value beyond the structured fields.

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

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

States a specific verb (create) and resource (document in a collection) with the source format (METS XML) and transport (multipart form data). The multipart phrasing implicitly distinguishes it from the sibling transkribus_coll_create_doc_from_mets_url, though siblings iiif/ftp are not named.

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?

Implies usage through source format and the upload mechanism, but never states when to prefer this tool over the sibling create_doc_from_mets_url, iiif, or ftp variants. No exclusions or prerequisites are given, leaving the selection decision to inference.

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

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

Annotations already declare readOnlyHint=false, openWorldHint=true, idempotentHint=false, and destructiveHint=false, so the safety profile is covered. The description adds nothing beyond that - it does not say whether the METS fetch is synchronous or job-based (the openWorldHint suggests an external network call that could fail or be slow), whether repeat calls with the same URL create duplicates, or what permissions are required. Given the lowered bar from annotations, this is thin rather than contradictory.

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

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

A single front-loaded sentence with no filler or repetition of the title. It is efficient, though its brevity is also the source of the gaps scored elsewhere rather than a virtue of structure alone.

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 creation tool with a fully covered schema and no output schema, the description is minimally sufficient. However, against a sibling set that contains four near-identical 'create document from X source' variants, it leaves routing and preconditions unresolved, so it is adequate but clearly incomplete.

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

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

Schema description coverage is 100% with only two required parameters (url, collId), both described in the schema, so the baseline is 3. The description confirms the url must be a METS resource but adds no format constraints or error semantics beyond the schema's format=uri.

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 gives a specific verb (Create), resource (document in a collection), and source qualifier (from a METS URL), which distinguishes it from the sibling variants that create documents from IIIF, FTP, or an uploaded METS file. It stops short of explicitly naming those siblings or the ambiguous transkribus_coll_create_doc_from_mets, so an agent must infer the routing from the URL phrasing alone.

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 when-to-use guidance, no statement of prerequisites (valid METS URL, write access to the target collection), and no explicit comparison with the near-identical siblings coll_create_doc_from_iiif, coll_create_doc_from_ftp, and coll_create_doc_from_mets. The reader has to infer everything from the tool 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?

Annotations say the operation is not read-only, not idempotent, and open-world, but the description adds no behavioral context beyond the bare creation statement. It does not explain side effects, whether an existing document is modified, what happens to the IOB data, or what the caller should expect afterward. No contradiction exists, but the description contributes little beyond the annotations.

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

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

A single, front-loaded sentence with no filler. Every word contributes to stating the action and the source format. There is no redundancy with the title or schema.

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

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

Despite full schema coverage, an agent is left without enough context to call this safely: no output schema, no explanation of what 'IOB import' means operationally, and no clarification of the optional-looking 'id' parameter. The tool is a non-idempotent creation action with open-world effectss, so more guidance about file source, target collection, and expected result is needed.

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

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

Schema description coverage is 100%, so the parameters are already documented individually. The description adds no extra meaning about how 'id', 'collId', and 'fileName' relate to the IOB import process. Baseline 3 applies because the schema carries the burden.

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

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

The description uses a specific verb ('Create') and resource ('documents from an IOB import'), clearly distinguishing this tool from sibling document-creation tools like from_mets, from_pdf, and from_iii. The format, IOB, is the key discriminator and is front and center.

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

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

The phrase 'from an IOB import' gives a clear contextual trigger: use this tool when the source data is an IOB-format import. It does not explicitly name alternative tools or exclusion conditions, but the IOB-specific context is strong enough that an agent can decide when this tool applies.

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

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

Annotations already indicate add operation (readOnlyHint=false, destructiveHint=false, idempotentHint=false). The description adds no further behavioral context, such as whether duplicate adds are allowed or what side effects occur (e.g., credit consumption).

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

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

One sentence, no unnecessary words. Front-loaded with the action and resource.

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

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

Given the tool's simplicity (2 params, no output schema), the description is minimal but adequate. However, it could mention expected return value or confirmation behavior, especially since annotations are not fully informative.

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

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

Schema coverage is 100% with clear descriptions for both parameters ('Collection ID' and 'Credit package ID to add'). The description does not add any additional 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 'Add a credit package to a collection' clearly states the action (add) and the primary resource (credit package) and target (collection). It distinguishes from sibling tools like transkribus_coll_credit_remove_package.

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 usage guidelines are provided. The description does not indicate when to use this tool versus alternatives (e.g., transkribus_coll_credit_list for viewing packages), nor does it mention prerequisites like whether the collection or credit package must exist.

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

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

The annotations already declare readOnlyHint, idempotentHint, openWorldHint, and non-destructive behavior, so the safety profile is covered. The description adds that the history is collection-scoped, but it does not describe pagination, sorting behavior, or what the returned history contains.

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

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

The description is a single, front-loaded sentence with no wasted words. It states the core action immediately and does not bury it under extraneous text.

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 schema and annotations carry most of the structural and safety context, but the description is thin for a tool with five parameters and many adjacent credit-related siblings. It omits return-value expectations and does not help the agent distinguish this from other credit-history endpoints.

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

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

Schema description coverage is 100%, so every parameter is already documented in the schema. The description adds no parameter-level meaning beyond the collection scope that is already captured by the required collId field.

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 clear verb and resource: 'Get the credit usage history for a collection.' It is specific and not tautological, but it does not distinguish this tool from several similar credit-history siblings such as transkribus_credit_get_history or transkribus_coll_credit_transactions.

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

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

The description gives no guidance about when to use this tool instead of the many other credit-related tools. There is no mention of alternatives, prerequisites, or exclusion conditions, so the agent must infer routing from the name and sibling list alone.

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

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

Annotations already declare readOnlyHint=true, idempotentHint=true, and destructiveHint=false, so safety is covered. The description adds nothing beyond the purpose line: it does not disclose pagination behavior, default filtering (onlyActive=true, includeExpired=true), or what a returned credit package includes, leaving meaningful behavior unexplained.

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

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

A single front-loaded sentence with zero waste; the verb and scoping are immediately clear. It is perhaps overly terse given the tool's eight parameters, but nothing is padded or redundant.

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

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

With eight parameters, no output schema, and no return-value documentation, the description should at minimum explain that results are filterable/paged credits and what fields a package contains. As written it is adequate only in the narrowest sense for such a parameter-rich tool.

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

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

Schema description coverage is 100%, so all eight parameters including index, nValues, minBalance, onlyActive, sortColumn and sortDirection are already documented in the schema. The description adds no extra syntax or constraints, so the baseline of 3 applies.

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

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

States a specific verb and resource ('List credit packages') scoped to a collection, which distinguishes it from coll_credit_transactions/credit_history siblings. However, it does not explicitly name which sibling to use for transactions versus packages, so the differentiation is implied rather than stated.

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 when-to-use guidance, no mention of prerequisites (e.g., the required collId being mandatory), and no routing to alternatives such as transkribus_credit_get_package_transactions or transkribus_coll_credit_history. The agent must infer all usage context.

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

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

Annotations already declare destructiveHint=true, idempotentHint=true. The description adds no additional behavioral context such as side effects, authorization needs, or what happens if the package doesn't exist. It is consistent with annotations, so no contradiction, but does not enhance information beyond them.

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

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

The description is a single, clear sentence with no unnecessary words. It is appropriately sized for a straightforward operation, though a bit more detail on the package removal process would not hurt.

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?

No output schema exists. The description does not indicate what the tool returns upon success or failure, nor does it mention any side effects or error conditions. For a removal tool, this is a significant gap.

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

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

Schema descriptions for both parameters ('Collection ID', 'Credit package ID to remove') are clear and cover 100% of parameters. The tool description adds no further meaning beyond the schema, meeting the baseline expectation.

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 and resource: 'Remove a credit package from a collection.' It distinguishes from sibling tools like 'add' and 'list' by using 'remove', though it could be more specific about the context (e.g., removing a previously added package).

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

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

No guidance on when to use this tool versus alternatives (e.g., credit removal via other methods), no prerequisites, and no conditions for safe usage. The description is purely declarative.

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

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

Annotations already declare readOnlyHint, idempotentHint, and destructiveHint=false, so the safety profile is covered. The description adds no behavioral context beyond the annotations—no pagination behavior, return shape, or permission requirements are described.

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

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

Single, front-loaded sentence with no filler. It is appropriately concise, though the terseness contributes to missing context elsewhere.

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 read-only transaction retrieval tool with five parameters and many similar siblings, the description is incomplete. It does not clarify scope (all collection transactions vs. history vs. list) or mention required collId and pagination/sorting options, all of which are needed to select and invoke correctly.

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

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

Schema coverage is 100%, and each parameter (collId, index, nValues, sortColumn, sortDirection) has a schema description. The tool description adds no additional parameter meaning, so the baseline of 3 applies.

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

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

Specific verb 'Get' and resource 'credit transaction records for a collection' are clear. However, it does not differentiate from sibling tools like transkribus_coll_credit_history, transkribus_coll_credit_list, and transkribus_credit_get_transactions, so an agent cannot tell which to use without opening schemas.

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

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

No explicit when-to-use guidance, no alternatives named, and no exclusions. The description only implies it is for retrieving collection credit transactions; it does not say when to prefer it over similar credit-history or listing tools.

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

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

The description simply restates the action already implied by the tool name and annotations; it adds no behavioral context beyond the structured hints. It does not mention that deletion is permanent, what happens to contained documents, or any permission requirements. It does not contradict the annotations, but it contributes no additional transparency.

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

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

The description is a single, front-loaded sentence with no filler or redundancy. Every word contributes to the core meaning, making it an appropriately concise definition.

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

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

For a simple delete action with a fully documented schema and a destructiveHint annotation, the core invocation information is present. However, the definition lacks any usage alternatives, behavioral warnings, or clarification of what happens when force is false and the collection is non-empty, leaving the agent to infer important operational context on its own.

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

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

Schema description coverage is 100%, so the baseline applies: both collId and force are already documented in the schema. The description's 'by ID' phrasing mirrors collId but adds no new parameter semantics, and it says nothing about the force parameter.

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) and the resource (a collection), qualified by ID, so the tool's purpose is unambiguous. It does not explicitly distinguish itself from siblings like transkribus_coll_delete_empty or transkribus_doc_delete, but the 'by ID' qualifier provides some differentiation.

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 transkribus_coll_delete_empty or when a force delete is appropriate. The only implied usage is that the caller has a collection ID, but no explicit scenarios, prerequisites, or exclusions 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?

Annotations include destructiveHint: true and idempotentHint: true. The description adds the conditional behavior (only if empty), which is not captured by annotations. 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?

Single short sentence that front-loads the key behavior. 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 conditional delete with one parameter and no output schema, the description is adequate. It could mention error handling (e.g., if collection not empty or not found), but the core behavior is clear.

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?

Only one parameter 'collId' with schema description 'Collection ID'. Schema coverage is 100%, so description does not add extra meaning beyond the schema. Baseline 3.

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

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

The name 'Delete Empty Collection' and description 'Delete a collection only if it is empty.' clearly state the action and condition. This distinguishes it from 'transkribus_coll_delete' which presumably deletes any collection.

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

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

The description implies when to use (safe deletion of empty collections). It does not explicitly state prerequisites or when not to use, but the sibling tool name suggests an alternative for non-empty collections.

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

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

Annotations already convey that this is a mutating, non-idempotent, non-destructive operation, but the description adds no additional behavioral context. It does not disclose whether a new collection is created, whether documents and members are copied, or whether duplicate operations are asynchronous or require special permissions. No contradiction exists, but the description does not go beyond the structured annotations.

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

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

The description is a single, front-loaded sentence with no redundant wording. It states the action and target resource directly, making the tool easy to scan and understand.

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

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

For a one-parameter tool with 100% schema coverage and relevant annotations, the description is minimally viable. However, it leaves some ambiguity about whether collId refers to the source collection only, what the output is (e.g., a new collection ID), and whether duplication is asynchronous or blocks until 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 schema provides 100% coverage with a clear 'Collection ID' description for collId, so the baseline is 3. The tool description does not add parameter-level details, but the single parameter is already well-documented by the schema.

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

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

The description uses the specific verb 'Duplicate' with the resource 'an entire collection', which clearly states what the tool does. It also distinguishes itself from the sibling transkribus_coll_duplicate_doc by indicating this operates at the collection level rather than document level.

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 offers no guidance on when to use this tool versus alternatives like transkribus_coll_create, transkribus_coll_export, or transkribus_coll_duplicate_doc. It also does not mention any prerequisites, naming behavior, or cases where this tool should be avoided.

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 indicate readOnlyHint=false, but description does not disclose behavior beyond duplication. No mention of side effects, permissions needed, or whether the original document is affected. With no output schema, the return value is also opaque.

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?

Description is extremely short (one sentence) but under-specifies the tool's capabilities. It is not appropriately sized; it loses points for lacking necessary details.

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

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

Given 4 parameters, no output schema, and sparse annotations, the description is incomplete. It does not explain the duplication destination options, the effect of optional parameters, or what the response contains (e.g., new doc ID).

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

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

Schema description coverage is 100%, so baseline is 3. The description 'Duplicate a document within a collection' adds no additional meaning beyond the schema's param descriptions. It does not clarify optionality of targetCollId or name default behavior.

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 verb 'Duplicate' and resource 'document within a collection', but is ambiguous about scope: it could mean only within the same collection, yet parameters allow copying to a different collection via targetCollId. It does not differentiate from sibling transkribus_coll_duplicate which duplicates the whole collection.

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

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

No guidance on when to use this tool vs alternatives, prerequisites, or when not to use. For example, no mention of when to use transkribus_coll_add_doc or transkribus_coll_duplicate instead.

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 indicate a write operation that is not read-only, not idempotent, and not flagged as destructive. The description only repeats the import concept and adds no behavioral context about side effects, such as whether existing metadata is overwritten, whether documents are created, or whether the operation can be safely repeated. With annotations covering only basic hints, the description fails to disclose meaningful behavioral traits.

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

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

The description is a single clear sentence with no filler or repetition. It front-loads the action and target, making it easy to scan. Nothing in the description is wasted, though it is quite terse.

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 mutation-like import operation with no output schema, the description is too sparse. It does not explain what happens after import, whether fileName refers to a local or server-side file, whether the operation affects existing metadata, or what results the agent should expect. These gaps matter because the required parameter is only collId, leaving fileName's role ambiguous.

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

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

Schema description coverage is 100%: collId is documented as 'Collection ID' and fileName as 'EAD file name'. The description adds no additional semantic nuance, such as the required format of fileName or why fileName might be optional while collId is required. This meets the baseline for a tool whose schema already documents its 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 uses a specific verb ('Import') and names the resource ('EAD metadata') along with the destination ('a collection'). It also denotes the importer's general scope, making it reasonably distinguishable from many other collection-related tools, though it doesn't explicitly differentiate it from sibling tools that handle metadata updates or bulk uploads.

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 offers no explicit guidance on when to use this tool versus alternatives such as transkribus_coll_update_metadata, transkribus_upload_bulk_update_isad_metadata, or document creation tools. It implies the use case of importing EAD metadata, but it does not state prerequisites, exclusions, or when another tool would be preferable.

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

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

Annotations already declare readOnlyHint=true, destructiveHint=false, idempotentHint=true. The description adds no extra behavioral context (e.g., what the tool returns, whether it creates a download, any side effects). It does not contradict annotations, but the minimal description doesn't add value beyond them.

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

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

The description is a single sentence that is concise and front-loaded with the key action and resource. Every word earns its place; no extraneous text.

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 does not explain what the tool returns (e.g., a download URL, file, or status), nor does it clarify whether it exports all documents or selected ones (despite the 'pages' parameter). With no output schema, this omission significantly reduces completeness for a tool that initiates an export.

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

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

Schema description coverage is 100%, so the schema already describes all parameters (collId, pages, format) with examples and types. The tool description adds no additional meaning or clarification to the parameters, making it adequate but not helpful 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 documents from a collection in the specified format,' providing a specific verb (export) and resource (documents from a collection). It distinguishes this tool from sibling tools like transkribus_doc_export, which exports a single document.

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

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

No explicit guidance on when to use this tool versus alternatives (e.g., transkribus_doc_export). The description lacks context for when this tool is appropriate and does not mention prerequisites or exclusions.

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

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

Annotations already declare readOnlyHint=true, idempotentHint=true, and destructiveHint=false, so the safety profile is covered. The description adds only 'across collections' and 'using filters' as behavioral context. It does not disclose pagination defaults, result count limits, or how filters combine (AND vs OR, partial vs exact match), though nValues, index, exactMatch, and caseSensitive parameters suggest these behaviors matter. With strong annotations, a 3 is appropriate — the description adds minimal context beyond them but does not contradict them.

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

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

The description is a single clear sentence with no fluff or repetition of the title. It is front-loaded with the core action. It could arguably add more operational detail, but as written it is efficiently structured with zero wasted words, which is slightly above the minimum viable bar.

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 29 optional parameters and no output schema, the description is far too thin. It does not explain what the returned documents look like, how pagination behaves, whether results span all accessible collections or require a collId, or how this differs from transkribus_coll_find_documents_post/old and transkribus_coll_count_find_documents. The annotations cover safety but not operational completeness, and the schema's terse 'Filter by X' descriptions leave search semantics unclear.

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

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

Schema description coverage is 100%, so the schema carries the documentation burden for all 29 parameters and the baseline is 3. The schema's parameter descriptions are terse ('Filter by ID', 'Filter by description') but some do add semantics ('Number of results (-1 for all)', 'Start index (0-based)', 'Sort direction: asc or desc'). The tool description itself adds no parameter-level meaning beyond what the schema provides, so it does not push above baseline.

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

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

The description states a specific verb ('Search') and resource ('documents across collections') and notes that filtering is supported. This is clearly a query/read tool. However, it does not differentiate from the closely named siblings transkribus_coll_find_documents_post, transkribus_coll_find_documents_old, and transkribus_coll_count_find_documents, so an agent cannot tell which variant to pick from the description alone.

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

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

No guidance is given on when to use this tool versus alternatives such as transkribus_coll_find_documents_post, transkribus_coll_find_documents_old, or transkribus_coll_count_find_documents. There is also no mention of prerequisites (e.g., whether collId is expected, authentication requirements, or when the count variant would be more appropriate). The description leaves all selection logic to the agent.

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

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

Annotations already declare readOnlyHint=true, idempotentHint=true, openWorldHint=true, and destructiveHint=false, covering the safety profile. The description adds only the word 'legacy,' which hints at deprecation status but provides no behavioral context such as pagination semantics of index/nValues, result limits, or differences from the current endpoint. No contradiction with annotations, but minimal added value.

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

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

The single sentence is efficiently short, but it borders on under-specification rather than genuine conciseness. 'Legacy endpoint' adds nothing beyond the title, and no other information is front-loaded because there is no other 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 14-parameter tool with no output schema sitting in a dense cluster of sibling find_documents tools, a one-line description is grossly inadequate. An agent cannot determine which endpoint this calls, how results are returned, how it differs from the modern variant, or what the legacy constraints are.

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

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

Schema description coverage is 100%, so the schema fully documents all 14 parameters. The description adds nothing about parameter meaning or relationships beyond what the schema provides, so the baseline score of 3 is appropriate.

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

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

States a verb and resource ('Search for documents'), but 'the legacy endpoint' is vague and merely restates the title's 'Legacy'. With three near-identical siblings (transkribus_coll_find_documents, transkribus_coll_find_documents_post, transkribus_coll_count_find_documents), it fails to clarify what distinguishes this variant. Purpose is clear at a high level but not specific enough to differentiate.

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 whatsoever on when to use this tool versus the non-legacy find_documents variants or the count variant. An agent has no way to know whether 'legacy' means deprecated, restricted, or preferred for certain cases. No exclusions, prerequisites, or alternatives are mentioned.

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

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

Annotations already declare readOnlyHint=true and destructiveHint=false, so the safety profile is clear. The description adds only the transport detail 'using a POST request body', which is minimally informative beyond the name. It does not disclose result pagination or limits, but annotations lower the burden here.

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

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

One sentence with no filler, clearly stating the operation and the transport mechanism. It is efficient but somewhat terse, repeating the POST detail already present in the title.

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 search tool with 9 optional parameters and no output schema, the description is too thin. It does not explain what the response contains, what happens when no filters are provided, or how this tool compares to the sibling find-document variants. An agent would struggle to know what to expect or when to prefer this tool.

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

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

Schema description coverage is 100%, meaning every parameter already has its own description. The tool description adds no parameter-level meaning beyond the schema, so the baseline 3 applies.

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

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

States a specific verb+resource: 'Search for documents across collections'. The phrase 'using a POST request body' helps distinguish it from GET-based sibling search tools, though it does not explicitly name the 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?

No guidance on when to use this POST variant versus transkribus_coll_find_documents, transkribus_coll_find_documents_old, transkribus_coll_list_docs, or transkribus_search_fulltext. The description only identifies the HTTP method, leaving the selection criteria unstated.

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

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

Annotations already indicate readOnlyHint=true, idempotentHint=true, and destructiveHint=false, so the safety profile is established. The description adds no further behavioral context, such as whether stats inclusion affects response size or whether metadata is minimal versus full. With annotations covering the main behavioral traits, a 3 is appropriate.

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

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

The description is a single, clear sentence with no waste. It is front-loaded with the action and resource. It earns a 4 rather than 5 because it does not include a brief note about the optional stats parameter, which could help the agent decide whether to pass it.

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

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

For a simple read-only metadata retrieval with full schema coverage and safety annotations, the description is adequate. However, it does not explain what 'metadata' includes or how the stats flag changes the output, and there is no output schema to clarify the return shape. This leaves minor ambiguity but not critical gaps.

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

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

Schema description coverage is 100%, so both parameters (collId and stats) are already documented in the schema. The description itself adds no additional parameter-level meaning. The 'stats' parameter's effect on response content is not elaborated beyond 'Include statistics', but the schema handles the baseline.

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

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

The description 'Get metadata for a collection' clearly identifies the verb ('Get') and the resource ('metadata for a collection'), so purpose is clear. However, it does not distinguish itself from sibling tools like transkribus_coll_get_recent_collections, transkribus_coll_list, or transkribus_coll_user_stats, which could also be interpreted as retrieving collection-related information.

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 conveys a straightforward read operation but offers no explicit guidance on when to use this tool over alternatives such as transkribus_coll_list, transkribus_coll_get_recent, or transkribus_doc_get_metadata. The context is clear for a generic metadata fetch, but no exclusions or alternative conditions are provided.

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

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

The annotations already declare readOnlyHint=true, idempotentHint=true, and destructiveHint=false, so the safety profile is covered. The description adds the basic scope of 'recently accessed items' but does not disclose pagination behavior, result format, or what 'recent' means.

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

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

The description is a single concise sentence with no filler or repetition, which makes it easy to parse. However, its brevity sacrifices clarity because 'items' is undefined and no differentiation from nearby siblings is provided.

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

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

With no output schema, the description should clarify what the returned items are and how the list is structured, but it does not. The tool's name is ambiguous relative to transkribus_coll_get_recent_documents and transkribus_coll_get_recent_collections, and the description does not resolve this ambiguity.

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

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

Schema description coverage is 100%, so the parameters are already documented with meaningful descriptions. The tool description does not add parameter-level semantics beyond confirming the collection context, so the baseline of 3 is appropriate.

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

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

The description states a specific action ('Get') and resource ('recently accessed items in a collection'), and the required collId parameter clarifies the scope. However, 'items' is vague and the tool is not clearly differentiated from transkribus_coll_get_recent_documents or transkribus_coll_get_recent_collections.

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 this is for retrieving recent entries within a specific collection, but it does not explicitly say when to prefer this tool over the similar sibling tools. There are no exclusions or alternative guidance, so the usage context is only implied.

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

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

Annotations already declare readOnlyHint=true, idempotentHint=true, and destuctiveHint=false, covering the safety profile. The description adds the 'recently accessed' behavioral scoping, but it does not disclose return format, pagination, or any auth expectations, so additional context is limited.

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

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

The description is a single front-loaded sentence with no wasted words. Every word contributes to the tool's purpose, and there is no unnecessary verbosity.

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

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

Despite 4 parameters and no output schema, the description only offers a minimal phrase. It does not explain how the parameters interact, what the returned list looks like, or how this tool relates to the many nearby collection-list siblings, leaving an agent under-informed for correct invokation.

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

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

Schema description coverage is 100%, so the schema already documents the index, nValues, sortColumn, and sortDirection parameters. The description adds no param-level meaning beyond that, which keeps it at the baseline for complete schema coverage.

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

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

The description states a clear verb+resource ('Get recently accessed collections'), so an agent knows what the tool does. However, it does not differentiate it from the sibling tool transkribus_coll_get_recent, which appears to overlap in function, so it stops short of full sibling distinction.

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 such as transkribus_coll_get_recent, transkribus_coll_list_paged, or transkribus_coll_list. There is no mention of exclusions, prerequisites, or a preferred context.

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

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

Annotations already declare readOnlyHint=true, idempotentHint=true, and destructiveHint=false, so the basic safety profile is covered. The description adds only the scoping to 'recently accessed documents,' which is mildly useful but does not disclose details like whether the results reflect the current user's access history or a global history.

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

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

The description is one short sentence with no waste. It is appropriately sized, though it could have earned more by adding sibling differentiation.

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 four parameters (index, nValues, sortColumn, sortDirection) and no output schema, the description is too thin to be complete. It does not specify what fields the returned documents contain, how sorting works, or how this differs from get_recent/get_recent_collections.

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

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

Schema coverage is 100%, so the schema already documents all four parameters. The description itself adds no meaning beyond the schema; it is the minimal baseline.

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

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

The description states a specific verb ('Get') and resource ('recently accessed documents'), which is clear enough. However, it does not differentiate from sibling tools like transkribus_coll_get_recent or transkribus_coll_get_recent_collections, which could overlap in function.

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

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

No guidance is provided on when to use this tool versus alternatives. The description lacks context such as whether it replaces get_recent or how it differs from get_recent_collections, so an agent has no way to choose among related siblings.

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

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

The description adds no behavioral details beyond what annotations already provide (readOnlyHint, idempotentHint). It does not explain what happens with invalid collection IDs, the output format, or any safety cues. Minimal value added beyond structured annotations.

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

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

The description is a single, front-loaded sentence that efficiently states the tool's purpose. No unnecessary words or repetition. Perfectly concise.

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

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

With no output schema and only 2 parameters, the description should provide more context about the result format or common usage scenarios. It fails to compensate for the missing output schema, leaving the agent underinformed.

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

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

Schema description coverage is 100% with clear definitions for collId and legacy. The description adds no additional parameter meaning, so the baseline of 3 is appropriate.

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

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

The description clearly states the verb 'List' and the resource 'tag definitions for a collection.' It is specific, but does not differentiate from sibling tools like transkribus_coll_get_metadata or transkribus_coll_label_list. A score of 4 reflects clarity without sibling differentiation.

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. The description lacks any context about prerequisites, conditions, or comparison to other tools for listing similar data. This is a significant gap.

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

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

Annotations already declare readOnlyHint=true, destructiveHint=false, idempotentHint=true, openWorldHint=true. The description adds the scope 'associated with a collection' but does not disclose additional behavioral traits like pagination or sorting behavior. With annotations covering safety, a 3 is appropriate.

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

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

The description is a single sentence with 7 words, highly concise and front-loaded. However, it lacks any additional context that would justify a perfect score; it is efficient but minimal.

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

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

Given the tool has 6 parameters including pagination (index, nValues) and filtering (sortColumn, sortDirection, isDeleted), the description fails to mention these capabilities or any output format. No output schema exists, so more explanation was needed.

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

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

Schema description coverage is 100%, so all 6 parameters have descriptions in the schema. The tool description adds no parameter-level details beyond what is already documented. Baseline 3 is correct as the schema carries the burden.

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

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

The description clearly states the verb 'List' and the resource 'labels' with the qualifier 'associated with a collection', which distinguishes it from sibling tools like transkribus_label_list that list all labels.

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 (e.g., transkribus_label_list) nor any prerequisites or exclusions. It is a simple statement without usage context.

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

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

The annotations already establish that this is a read-only, idempotent, non-destructive operation. The description adds useful scope by saying only collections accessible to the current user are returned. It does not disclose pagination behavior, filtering behavior, or what the response contains.

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

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

The description is a single front-loaded sentence with no wasted words. It immediately conveys the action, resource, and scope.

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 gives the essential scope, but for a list tool with ten optional filtering, sorting, and pagination parameters it omits any mention of those capabilities. The schema covers parameters and annotations cover safety, so this is minimum viable rather than fully complete.

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

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

Schema description coverage is 100%, so all ten optional parameters are already documented in the input schema. The description adds no parameter-level meaning beyond that, which makes a baseline score of 3 appropriate.

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

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

The description clearly states a specific verb and resource: list collections. It also scopes the result to those accessible to the current user. However, it does not distinguish this tool from close siblings such as transkribus_coll_list_paged or transkribus_coll_list_by_name.

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. Siblings like transkribus_coll_list_paged and transkribus_coll_list_xml exist, but the description does not explain when this unpaged list is appropriate.

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

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

Annotations already declare readOnlyHint=true, idempotentHint=true, and destructiveHint=false, so the safety profile is clear. The description adds only the name-search scope and does not describe output format, pagination defaults, or exactMatch behavior, but it does not contradict the annotations.

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

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

The description is a single front-loaded sentence with no filler, making it concise. However, it is minimal to the point of omitting useful context, so it does not earn a 5.

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

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

For a read-only list tool with full parameter schema and safety annotations, the description is minimally adequate. However, with no output schema and many sibling list/search tools, the agent is left to infer return shape and when to choose this over alternatives.

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

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

Schema description coverage is 100%, so the description does not need to redefine the six parameters. It adds no extra defaults or semantics such as the meaning of nValues=-1 or how exactMatch changes behavior, keeping this at the baseline.

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

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

The description states a clear verb ('Search') and resource ('collections') with a name-based scope, and the title reinforces the same idea. It does not explicitly contrast with sibling collection-listing tools, but the 'by name' qualifier distinguishes it from generic list variants.

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 when-to-use guidance or alternatives are provided; the description only restates the tool's purpose. Given many sibling tools like transkribus_coll_list, transkribus_coll_list_paged, and transkribus_coll_list_for_user, an agent gets no help deciding which tool to choose.

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

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

Annotations already declare readOnlyHint=true and non-destructive, so the description's minimal addition of 'with pagination' does not significantly enhance transparency. No disclosure of performance, rate limits, or return format.

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

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

The description is a single short sentence with no redundancy. It could be slightly expanded to include more context without losing conciseness, but it is efficient.

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

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

With 24 parameters and no output schema, the description is too minimal. It lacks information about return values, default pagination behavior, and how this tool differs from other list/search tools. Annotations partially compensate, but the description remains incomplete.

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

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

Schema covers 100% of parameters with descriptions. The description's mention of pagination aligns with index/nValues parameters but adds no new meaning 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 lists documents in a collection and mentions pagination. However, it doesn't explicitly differentiate from sibling tools like transkribus_coll_find_documents or transkribus_coll_list_docs_xml, which have similar purposes.

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 (e.g., filtered search or document counting). No contextual clues such as 'use when you need all documents without filters'.

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

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

Annotations already declare readOnlyHint=true, destructiveHint=false, idempotentHint=true, and openWorldHint=true, covering the safety profile. The description adds only that the output is XML; it omits pagination behavior (index/nValues), deleted-document inclusion, and whether 'all documents' is affected by the default nValues=0.

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

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

The description is a single front-loaded sentence with no filler or repetition. It is appropriately concise for a simple list operation.

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