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

No annotations provided, so description bears full burden. It implies a destructive mutation but lacks details on side effects, reversibility, or required permissions.

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

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

Two sentences, front-loaded with the action. 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?

Adequate for a simple tool with one param and output schema, but lacks behavioral context (e.g., what happens on success/error) and usage guidance.

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?

Adds context that backup_id is 'Numeric ID', but schema says string, causing inconsistency. With 0% schema description coverage, the description partially compensates but could be clearer.

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 'Abort the currently running backup task for a job' with a specific verb and resource, distinguishing it from sibling tools like run_backup or list_backups.

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. It does not specify prerequisites or situations where abort should be used, such as only when a backup is running.

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

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

With no annotations, the description indicates a read-only operation by saying 'Return', but does not explicitly state safety, idempotency, or any potential side effects. It discloses the kind of data returned but lacks details on performance or error handling.

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

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

The description is concise, using three short sentences plus an Args line. Every sentence adds value, no redundant or extraneous text, and the structure is clear and easy to scan.

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

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

Given the tool has a single parameter, an output schema (present but not shown), and no nested objects, the description covers all necessary context: what the tool returns, what data it includes, and how to find the backup ID. It is complete 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?

The input schema has 0% description coverage, but the description adds an 'Args' section clarifying that backup_id is a numeric ID (though typed as string) and provides guidance to use list_backups. This adds meaning beyond the schema's bare property definition.

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

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

The description clearly states it returns rich metadata for a backup job, listing specific fields like last run date, duration, file counts, quota usage, and last error. It also distinguishes itself from the REST API by noting it is more detailed, differentiating it from sibling tools like get_backup and list_backups.

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

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

The description provides context by stating it is from the local SQLite database and is more detailed than the REST API, implying use when detailed metadata is needed. It also instructs to use list_backups to find IDs, but does not explicitly exclude use cases or mention when not to use this tool over alternatives like get_backup.

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

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

No annotations are provided. The description discloses that sensitive values like passphrases are excluded, adding some behavioral context. However, it does not explicitly state that the operation is read-only, nor does it mention permission requirements or error conditions, leaving gaps in transparency.

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

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

The description is concise, starting with a clear one-line purpose, then listing key details and parameters. Every sentence adds meaningful information without redundancy.

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

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

The tool has an output schema, so the description does not need to detail return values. It covers included options and excluded sensitive values. However, it lacks mentions of prerequisites (e.g., backup job existence) or error handling, leaving minor 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?

With 0% schema description coverage, the description adds value by specifying that backup_id is a 'Numeric ID', while the schema only defines it as a string. This clarifies the expected format 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 'Return the configuration options for a backup job', specifying the verb and resource. It lists specific details like compression, encryption, retention policy, differentiating it from siblings such as db_get_backup_metadata and db_get_backup_schedule.

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

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

No guidance is provided on when to use this tool versus its siblings (e.g., db_get_backup_metadata, export_backup_config). The description only explains what the tool returns, not the context or decision criteria for selecting 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?

The description implies a read-only operation ('Return') but does not explicitly confirm no side effects or authentication requirements. With no annotations, more transparency is needed.

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

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

The description is concise with a single main sentence and a parameter list. It is efficient but could be better front-loaded.

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

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

For a simple read with an output schema, the description is minimal but functional. It lacks additional context about the schedule configuration content and does not address the type inconsistency.

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

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

The description adds meaning by calling backup_id a 'Numeric ID' but contradicts the schema type (string). Schema coverage is 0%, so description must compensate, but the type mismatch may confuse agents.

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 returns the schedule configuration for a backup job, using specific verb and resource. It effectively distinguishes from siblings like db_get_backup_metadata and db_get_backup_options.

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 only states what it does, not when it should be chosen over siblings.

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

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

With no annotations, the description carries the full burden of behavioral disclosure. It only states that it returns data, but does not mention any behavioral traits such as idempotency, authentication requirements, rate limits, or side effects. The implicit read-only nature is not explicitly confirmed.

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

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

The description is concise with three sentences and a parameter list. It front-loads the purpose and immediately follows with prerequisite guidance. Every sentence adds value with no redundancy.

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

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

Given the presence of an output schema (which describes return values), the description covers the essential purpose and usage. It does not elaborate on constraints (e.g., required state of the operation) but is sufficient for an experienced user.

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?

Despite 0% schema description coverage, the description adds meaning to both parameters: backup_id is 'Numeric ID of the backup job' and operation_id is 'Numeric ID of the operation (from db_list_operations).' This clarifies their source and format, though the schema types are strings.

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 purpose: 'Return the detailed log and result statistics for a specific operation.' It uses a specific verb and resource, and distinguishes itself from siblings by focusing on log and result details for a single operation, referencing db_list_operations for finding operation IDs.

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

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

The description provides a clear usage instruction: 'Use db_list_operations to find operation IDs.' This tells the agent when to use this tool relative to a sibling. However, it does not explicitly state when not to use it or give alternative tools for similar tasks.

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

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

No annotations are provided, so the description must disclose behavioral traits. It does not specify that the tool is read-only, whether authentication is needed, or any side effects. The description only states it lists errors, which is insufficient for a tool lacking annotations.

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

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

The description is very concise, with a clear main sentence followed by parameter documentation. Every sentence is useful, and there is 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?

Given the tool has an output schema (not shown), the description does not need to explain return values. However, it lacks context on ordering, error handling, or performance implications. For a simple list tool with two parameters, it is adequate but not comprehensive.

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

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

Schema coverage is 0%, so the description must compensate. It provides meaningful context for both parameters: backup_id is 'Numeric ID of the backup job (leave empty for all jobs)' and limit is 'Maximum number of entries to return (default 20)'. This adds value beyond the schema's type and default.

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', the resource 'recent error log entries', and the scope 'from the local SQLite database'. It distinguishes from sibling tools like db_list_operations and db_list_notifications.

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

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

The description implies usage for listing errors but does not explicitly state when to use this tool vs alternatives like db_get_operation_log or server status tools. No exclusions or prerequisites are mentioned.

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

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

With no annotations, the description carries the full burden of behavioral disclosure. The tool lists restore points, but the description does not state whether it is read-only, requires authorization, or has any side effects. For a simple list operation, the lack of explicit read-only confirmation is a gap.

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

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

The description is concise, starting with a one-line summary followed by parameter explanations in a clear list. It could be slightly more compact, but it is well-structured and front-loaded.

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

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

Given that an output schema exists, the description does not need to detail return values. It covers the essential purpose, parameters, and default limit. However, it lacks any mention of pagination, ordering, or the format of the returned filesets, which the output schema likely provides.

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

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

The schema has 0% description coverage, but the tool description explains both parameters: 'backup_id: Numeric ID of the backup job' and 'limit: Maximum number of filesets to return (default 20).' This adds meaningful context beyond the bare schema titles and types.

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

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

The description clearly states the tool's purpose: 'List available restore points (backup versions) for a backup job.' It uses a specific verb ('List') and resource ('restore points/backup versions'), and clearly distinguishes from sibling tools that deal with backups but not listing restore points.

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 like db_get_backup_metadata or list_backups. It does not specify prerequisites, such as needing a valid backup_id, nor does it mention when not to use it.

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

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

No annotations provided, so description carries full burden. Only states basic action; no disclosure of read-only nature, authentication needs, side effects, or ordering. Minimal 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?

Extremely concise: two sentences plus args list. Front-loaded with purpose. Every sentence adds value, 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?

Output schema exists (not shown) so return details not needed. Adequately covers purpose and parameter, but could mention ordering (e.g., by time) or that it returns system notifications. 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?

Only one parameter 'limit', with schema coverage 0%. Description adds meaning: 'Maximum number of entries to return (default 20)' – clarifies purpose and default beyond schema.

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

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

Clearly states verb (list), resource (system notifications), and scope (recent, from local SQLite database). Distinguishes from sibling list tools like db_list_errors and db_list_operations by specifying 'notifications (update alerts, etc.)'.

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 for listing notifications, but no explicit guidance on when to use this versus sibling tools like db_list_errors or db_list_operations. No when-not-to-use or alternative suggestions.

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

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

With no annotations, the description carries full burden. It implies a read operation ('Reads from...'), but does not explicitly confirm non-destructiveness, permission requirements, or rate limits. The description adds basic context but lacks depth.

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 concise with two sentences and an Args block. Front-loaded with the main purpose. No superfluous 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?

Given the tool's simplicity (2 parameters, output schema exists), the description covers the basic functionality. However, it omits details like ordering of operations, time range for 'recent', or pagination behavior.

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

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

Schema coverage is 0%, so description must compensate. It mentions 'Numeric ID' for backup_id, but the schema defines it as a string, which is a potential contradiction. Only minimal extra meaning is added beyond the schema.

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

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

The description clearly states the verb 'List' and the resource 'recent operations' for a backup job. It distinguishes itself by specifying it reads from a per-backup SQLite database, but does not explicitly differentiate from sibling 'db_get_operation_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?

No guidance on when to use this tool vs. alternatives like db_get_operation_log or other sibling tools. Does not state prerequisites or limitations.

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

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

No annotations are provided, so the description must supply behavioral details. It fails to disclose whether the operation is read-only (likely true but not stated), what permissions are needed, or if any side effects exist (e.g., does it create files?). The only behavioral info is that it returns a JSON string, but no further context on safety or state changes.

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

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

The description is extremely concise: a single sentence stating purpose plus a one-line Args section. Every word serves a purpose, with no redundancy or filler. The structure is front-loaded with the action, making it easy for an agent to parse quickly.

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

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

Given the tool's simplicity (one parameter, output schema present), the description is reasonably complete. It covers the action, output format, and parameter. However, it lacks mention of read-only nature or any prerequisites (e.g., backup must exist). For a tool with no annotations, these omissions keep it from being fully complete.

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

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

The schema provides only a parameter named 'backup_id' with type string and no description. The description adds significant meaning by clarifying that it expects a 'Numeric ID of the backup job to export.' This corrects the schema type (string to numeric) and explains the parameter's purpose, fully compensating for zero schema description coverage.

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

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

The description clearly states the tool exports a backup job configuration as a JSON string. The verb 'export' and resource 'backup job configuration' are specific, and the output format is explicit. This distinguishes it from sibling tools like get_backup (which likely returns full backup details) and import_backup_config (imports rather than exports).

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. For example, it does not explain when to use export_backup_config instead of get_backup or db_get_backup_*. The description lacks context on when to choose this tool over others in a workflow.

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

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

No annotations are provided, and the description only mentions 'detailed information' without specifying what is returned. The output schema exists but is not referenced. For a read-only operation, the behavioral disclosure is minimal but acceptable given the tool's simplicity.

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

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

The description is very concise with two short sentences that directly state the purpose and a key usage hint. 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?

Given the low complexity (one parameter, output schema provided), the description is complete: it explains what the tool does and how to get the required input. No further detail is necessary.

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

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

Schema description coverage is 0%, but the description adds value by clarifying that backup_id is a 'Numeric ID' and how to obtain it ('use list_backups'), which is not evident from the schema alone. However, it doesn't explain the expected format beyond numeric.

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 detailed information about a specific backup job' clearly identifies the verb ('get') and resource ('backup job'), and distinguishes it from siblings like 'list_backups' which list all jobs.

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 instructs to use 'list_backups to find IDs', providing a clear prerequisite. Although it doesn't explicitly state when not to use, the context is clear for a retrieval tool.

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

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

No annotations provided; description mentions 'live progress' indicating real-time data, and returns specific fields. However, does not disclose auth needs, rate limits, or behavior if no backup is running.

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 informative sentence with no redundant 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 zero parameters and presence of output schema, the description adequately explains what the tool returns and its purpose. No 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?

No parameters; description adds no extra parameter info needed. Schema coverage is 100%.

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

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

Clearly states verb 'Get', resource 'live progress of currently running backup task', and specifics 'phase, %, file counts'. It distinguishes from sibling tools like 'run_backup' or 'get_backup' by focusing on live progress.

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 use when a backup task is running, but does not explicitly state when not to use or mention alternatives. Context is sufficient for a simple polling tool.

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

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

With no annotations, the description carries the burden. It clearly lists what information is returned, implying a read-only operation. However, it does not mention idempotency, authentication requirements, or potential error conditions. The behavioral transparency is good but not fully comprehensive.

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

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

The description is a single, concise sentence that front-loads the purpose and lists included information. Every word adds value, with no unnecessary details.

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

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

Given the tool's simplicity (no parameters, has output schema), the description adequately covers the purpose and return types. It does not explain output structure, but that is provided by the output schema. Minor missing context: it could mention that this is a safe, read-only 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 input schema has zero parameters, and schema description coverage is 100%. Since there are no parameters to describe, the tool description does not need to add parameter semantics. According to guidelines, baseline is 4 for 0 parameters.

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

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

The description clearly states the tool retrieves server status, specifying the exact information returned: version, program state, active task, and scheduler info. It distinguishes itself from sibling tools, which focus on backups and database operations.

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 usage guidelines are provided. The description implies use for checking server status, but does not specify when to use this tool versus alternatives or provide exclusions. For a simple tool, this is adequate but lacks guidance.

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

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

No annotations provided, so the description must fully disclose behavior. It only states the import action without mentioning side effects, such as whether it overwrites existing configs, permissions needed, or error handling.

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

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

Two concise sentences with a clear parameter list. Every sentence adds value; no extraneous content.

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

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

The tool has an output schema, so return values may be documented there. However, the description lacks details on import behavior (e.g., whether it creates or updates) and prerequisites, which are important given siblings like update_backup_config.

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

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

The description adds meaning to config_json by specifying it is 'the backup configuration to import' and referencing the export format. This compensates for the 0% schema coverage, though more format details could be included.

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?

Clearly states the action (import) and resource (backup job configuration). The phrase 'as produced by export_backup_config' distinguishes it from sibling tools like update_backup_config or run_backup.

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?

Implicitly provides context by referencing export_backup_config, indicating this tool is the counterpart to export. However, it does not explicitly state when to use or not use this tool versus alternatives.

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

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

No annotations are provided, so the description must carry the full burden. It discloses the return fields (ID, name, last run date, result) but fails to mention any safety implications, error conditions, or whether authentication is needed.

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 redundancy. It is concise but could be slightly more structured to improve readability.

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

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

Given there are no parameters and an output schema exists, the description is fairly complete. However, it could mention the output format or that it returns all jobs without filtering.

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

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

There are no parameters, so schema coverage is trivially 100%. The description adds value by specifying the exact fields returned, which is helpful for an agent.

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

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

The description uses a specific verb ('list') and resource ('all configured Duplicati backup jobs') and distinguishes the tool from siblings like 'get_backup' which likely retrieves a single 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?

No explicit guidance on when to use this tool versus alternatives like 'db_get_backup_metadata' or 'get_backup'. The description implies it is for an overview but does not state 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?

No annotations exist, so the description must disclose behavioral traits. It only says 'trigger a backup job to run immediately' but does not explain whether the call is synchronous or asynchronous, what happens on error, or if the action is idempotent. Critical execution context is missing.

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

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

The description is concise with two sentences and a structured Args section. Every part is necessary, though it is slightly terse. No redundant information.

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

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

Despite the presence of an output schema, the description lacks essential context for a trigger action, such as whether the call returns immediately or waits for completion, error handling, and side effects. More detail is needed for safe invocation.

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

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

With 0% schema description coverage, the description adds value by explaining that backup_id is a 'Numeric ID of the backup job to run.' This clarifies the role and type, but does not provide validation constraints, sources for the ID, or format details.

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

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

The description clearly states 'Trigger a backup job to run immediately.' This is a specific verb+resource combination that effectively differentiates from sibling tools like abort_backup (abort) and list_backups (list).

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

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

No guidance is provided on when to use this tool versus alternatives. There are no prerequisites, no mention of required states (e.g., backup job must exist), and no hints about ordering or error conditions.

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

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

No annotations are provided, so the description carries the full burden. It states 'Update an existing backup job' implying mutation, but does not disclose whether the update is a full replacement or merge, what permissions are needed, if it triggers a backup immediately, or if it is idempotent. The description lacks important behavioral details beyond the basic operation.

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

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

The description is concise with two paragraphs: first states purpose and usage, second lists parameters. It is front-loaded with the main action, and each sentence adds value. Minor room for improvement: could merge the parameter list into a single line, but overall 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?

Given the tool is a mutation with 2 simple parameters and no annotations, the description should cover prerequisites, side effects, and output. It does not describe what happens after the update (e.g., returns success, modifies existing job), nor does it mention that the config_json must match the export format. An output schema exists but the description does not leverage it to explain return values.

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

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

Input schema has 0% description coverage. The description partially compensates: for backup_id it clarifies 'Numeric ID' (though schema says string), and for config_json it says 'Modified JSON string of the backup configuration'. This adds meaning over plain 'string' types, but does not provide format specifics, examples, or constraints, leaving some ambiguity.

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

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

The description clearly states 'Update an existing backup job from a modified JSON configuration', specifying the verb 'update' and resource 'backup config'. It distinguishes from siblings by referencing export_backup_config and listing modifiable fields like sources, settings, schedule, filters, making it distinct from import_backup_config or run_backup.

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

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

The description explicitly says 'Use this to modify ... on an existing job', providing clear usage context. It also mentions 'as exported by export_backup_config', guiding the agent on prerequisite steps. However, it does not explicitly exclude use for new jobs or contrast with import_backup_config, which might be used for importing a new config instead of updating.

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