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

No annotations are provided, so the description carries the full burden of behavioral disclosure. It only says 'Create', implying mutation, but gives no details about file reads/writes, side effects, permissions, or error handling. The mention of 'JSON file payload' does not clarify what the tool does with the input file or the optional output_file parameter. This is a significant gap for a tool that likely mutates the Anki collection.

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 concise but under-specified. It is not a case of efficient brevity; critical information is missing. The description does not earn its place because it fails to convey any actionable context beyond the name's obvious intent.

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 this is a mutation tool with no annotations, an output schema (not visible), and three parameters with zero schema coverage, the description is vastly incomplete. It does not explain the input file format, the meaning of the output file, the deck name default behavior, or any expected results. An agent cannot correctly invoke this tool without external knowledge about Cloze note creation and the file payload structure.

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

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

Schema description coverage is 0%, so the description must explain the parameters. It does not mention deck_name, input_file, or output_file at all, except indirectly via 'JSON file payload', which only hints at input_file. The required parameter input_file is undefined, and the optional deck_name and output_file have no meaning provided. The description fails to compensate for the schema's lack of parameter documentation.

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

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

The description states a specific verb ('Create') and resource ('Cloze deletion flashcard'), and hints at the input mechanism ('from a JSON file payload'). This distinguishes it from the generic add_note sibling, though it doesn't explicitly compare. It is reasonably clear what the tool accomplishes, but lacks details about the flashcard structure.

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

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

No guidance is given about when to use this tool versus the sibling add_note, nor any conditions or prerequisites. The description solely states what it does, not when it should be chosen. An agent has no basis to decide between this and other note-creation tools.

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

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

With no annotations, the description carries the full burden of behavioral disclosure. It only says 'Create', implying a mutation, but does not explain requirements (e.g., file format, permissions), side effects (e.g., overwriting existing notes), or the role of output_file. The minimal verb 'Create' gives a hint but almost no operational detail.

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, which is concise, but it is under-specified rather than appropriately sized. Given the tool has three parameters and an output schema, a one-liner that omits parameter semantics and usage context does not earn its place; it inadequately addresses the tool's complexity.

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

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

The description is severely incomplete for a tool with 3 parameters, no annotations, and an output schema. It does not explain the JSON payload format, what deck_name does, how output_file is used, or any edge cases. An agent cannot confidently call this tool correctly without further investigation, making it inadequate in context.

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

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

Schema description coverage is 0%, so the description must compensate by explaining the three parameters (deck_name, input_file, output_file). It does not mention any of them. The description adds no value beyond the bare property names in the schema, failing to clarify that input_file is the JSON payload path, deck_name is optional, and output_file likely stores results.

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 ('Create') and resource ('new flashcard note') with a specific source ('JSON file payload'), making it easy to understand the basic purpose. However, it does not differentiate from sibling tools like add_cloze_note or add_notes_batch, which also create notes, so it falls short of a 5.

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

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

There is no guidance on when to use this tool versus alternatives. It does not mention that add_cloze_note is for cloze deletions, add_notes_batch handles multiple notes, or any other selection criteria. An agent would have to infer usage from the name alone, providing no help in choosing among 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 provided, the description carries the full burden of behavioral disclosure. It only mentions that the operation is batch and reads from a JSON file, but does not disclose outcome, error handling, validation rules, side effects, or any performance characteristics beyond 'high-throughput'. This is a significant gap for a mutation tool.

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

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

The description is a single, concise sentence that is front-loaded with the primary action and object. It is appropriately short and to the point, with no redundant or filler language. Slightly more detail on input format would not violate conciseness, but the current structure is efficient.

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

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

For a batch operation with an output schema and two parameters, the description is incomplete. It does not specify the required JSON input structure, output behavior, error handling, or performance expectations. An agent cannot reliably prepare a valid call without additional context or examples.

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

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

Schema description coverage is 0%, so the description must compensate. It partially explains input_file as a 'JSON file' but does not clarify its expected format or contents. The output_file parameter is completely unexplained, leaving its purpose and default behavior ambiguous. The description adds minimal semantic value beyond the schema.

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

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

The description clearly states the action ('Add'), resource ('multiple flashcard notes'), and the method ('from a JSON file'). It distinguishes from single-note tools like add_note implicitly by emphasizing 'multiple' and 'batch'. However, it does not explicitly name sibling tools, so it is clear but not maximally differentiating.

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

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

The description gives no explicit guidance on when to use this tool versus add_note or add_cloze_note. 'High-throughput batch operation' implies use for many notes, but there is no explicit 'use this for bulk imports' or 'instead of add_note'. No alternatives or exclusions 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?

No annotations are provided, so the description must disclose behavioral traits. It only states the action (add) and bulk nature, but fails to mention whether tags are appended or replaced, what happens with duplicate tags, whether note_ids are required when using direct arguments, or any side effects. It also does not disclose that this is a mutating operation beyond the verb 'add'.

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 action and bulk nature. It avoids unnecessary phrasing and gets straight to the point. While it omits important details, it is not verbose, so it earns a high score on conciseness 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 tool with 4 optional parameters, 0% schema coverage, and no annotations, the description is critically incomplete. An agent cannot determine how to invoke the tool correctly: it lacks parameter explanations, the format of the JSON file, whether tags and note_ids must be provided together, the purpose of output_file, and any return value expectations. Given the complexity and lack of structured guidance, this is severely under-specified.

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

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

Schema description coverage is 0%, so the description must compensate. It mentions 'argument lists' and 'JSON file' which vaguely align with tags/note_ids and input_file, but it does not explain which parameters correspond to each source, nor does it mention output_file at all. The description adds minimal value for parameter understanding and does not clarify relationships or requirements.

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 (add tags) and resource (notes), and specifies bulk operation. It distinguishes from siblings like remove_tags_from_notes and add_note by the verb and prefixed 'bulk'. However, it does not explicitly name alternatives, so it is not as strong as a tool that does.

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

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

The description provides no explicit guidance on when to use this tool versus alternative tools. It implies use for adding tags to existing notes, but does not mention conditions for choosing input_file over argument lists, nor does it reference remove_tags_from_notes or add_note as alternatives. There is no when-not-to-use information.

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

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

With no annotations provided, the description must carry the full burden of behavioral disclosure. It only states the basic action (move) without mentioning side effects, permissions, reversibility, or behavior of the output_file parameter. It does not disclose whether the operation is destructive, what happens if the target deck doesn't exist, or how multiple selection methods interact. This is a significant gap given the mutation nature of the tool.

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

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

The description is a single sentence, concise and front-loaded with the primary action and selection methods. It avoids redundancy and gets to the point quickly, though it could expand slightly on parameter interactions without sacrificing 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?

Given the tool's complexity (6 parameters, 0% schema coverage, no annotations), the description is insufficient. It does not explain parameter exclusivity, the role of output_file, error handling, or prerequisites. While an output schema exists, the description still lacks critical context needed for correct invocation, such as whether card_ids and note_ids can be used together or if a target deck must exist.

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 explains the meaning of most selection parameters (card_ids, note_ids, query, input_file) and mentions target_deck_name, but it omits output_file entirely. It also does not clarify whether the selection methods are mutually exclusive or can be combined, nor does it specify the format of the input_file. With 0% schema description coverage, this leaves important semantics undefined.

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: 'Move cards to a target deck', listing specific selection methods (card IDs, note IDs, search query, input file). This clearly distinguishes it from sibling tools like suspend_cards or export_deck, which do different operations. The purpose is unambiguous.

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

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

The description implies that this is the tool for moving cards between decks, but it does not explicitly state when to use it versus alternatives or any prerequisites. There are no direct sibling tools for moving decks, so it implicitly stands alone, but no explicit guidance is given about when to choose it over others.

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

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

With no annotations provided, the description carries the full burden of behavioral disclosure. 'Create' implies a mutation, but it does not specify what happens if the deck already exists, whether permissions are required, if it is idempotent, or any side effects. The example hints at nested structure creation but leaves failure modes 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?

The description is a single, front-loaded sentence with a parenthetical example. Every word earns its place; there is no fluff or redundancy. It is concise and well-structured.

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

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

Given an output schema exists, return values are covered elsewhere, but the description still leaves key behavioral details unaddressed (e.g., duplicate handling, permission requirements) and completely omits the output_file parameter. For a mutation tool with two parameters and no annotations, this is 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 coverage is 0%, so the description must compensate. It adds meaning to deck_name through the '::' subdeck example, but it provides zero information about output_file. The description partially covers one parameter but leaves another entirely undocumented.

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 action ('Create a new deck or subdeck') and the resource (deck), with an example that clarifies the subdeck naming convention via '::'. This clearly distinguishes it from sibling tools like delete_deck, rename_deck, and change_deck.

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 example 'Computer Science::Algorithms' implies how to use deck_name for subdecks, providing some usage context. However, it does not explicitly state when to use this tool versus alternatives (e.g., change_deck) or any exclusions, so the guidance is implicit rather than explicit.

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

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

With no annotations, the description carries the full burden of behavioral disclosure. It explicitly states that the deck and all cards are deleted, which is a destructive cascade – a critical piece of information. However, it does not mention whether the deletion is permanent or if there is any kind of confirmation or restore mechanism, but the core destructive behavior is transparent.

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

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

The description is a single, efficient sentence with no filler. It front-loads the action and resource, then immediately states the identifier options. 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?

Although an output schema exists (so return values are covered), the description is incomplete for a destructive tool with three optional parameters. It fails to explain output_file, the cardinality requirement (one of deck_id/deck_name), and any potential error conditions or restrictions. An agent lacks sufficient information to call this tool safely and correctly.

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

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

Schema description coverage is 0%, so the description must explain the parameters. It mentions 'by deck ID or deck name' but does not clarify that exactly one should be provided, nor does it address the output_file parameter at all. The purpose of output_file is completely unexplained, leaving significant ambiguity for an agent deciding how to invoke the tool.

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

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

The description states the specific action 'Delete' on the resource 'deck' and explicitly notes the cascade to 'all cards contained within it.' This clearly distinguishes it from siblings like rename_deck or export_deck by indicating removal rather than modification or export.

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

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

There is no guidance on when to use this tool versus alternatives such as delete_notes or suspend_cards. It does not mention any conditions, such as whether the deck must be empty or if deletion is appropriate versus temporary suspension. No preconditions or exclusions 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?

With no annotations, the description must carry the full burden. It does disclose a key behavioral trait: cascading deletion of all cards generated from the notes. However, it does not mention irreversibility, permission requirements, confirmation steps, or what happens to associated media. This partial disclosure warrants a middle score.

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

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

The description is one concise sentence that front-loads the primary action and the cascade effect. Every word contributes meaning, and there is no redundancy or filler. It is well-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?

For a destructive operation with three optional parameters and no annotations, the description is too sparse. It lacks information about the JSON file format, the purpose of output_file, whether the inputs are alternatives or complementary, and any safety or confirmation behavior. An agent calling this tool would need to infer these details or look elsewhere, making it incomplete.

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

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

Schema description coverage is 0%, so the description must compensate. It explains that notes can be deleted by note_ids or from a JSON file list (input_file), adding meaning to those two parameters. However, it does not explain output_file at all, nor does it clarify whether note_ids and input_file are mutually exclusive or can be combined. This is incomplete compensation for zero schema coverage.

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

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

The description clearly states the action ('Delete notes'), the resource (notes), and adds a distinctive detail: it also deletes all cards generated from them. It also specifies two input methods (Note IDs or JSON file list), which distinguishes it from sibling tools like delete_deck. This is clear and specific.

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. It does not mention conditions, exclusions, or compare to delete_deck, update_note, or other note-related operations. The description is purely declarative and offers 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?

With no annotations provided, the description carries full behavioral burden. It only states the action and output types but omits critical details such as whether the operation modifies the deck, what happens if the deck does not exist, file overwrite behavior, error handling, or side effects on media files. The description also fails to mention that include_media controls whether media is bundled, which is a behavioral nuance.

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

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

The description is a single, concise sentence that front-loads the primary action and output formats. There is no extraneous information, and every word contributes to understanding the tool's core function.

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 four parameters, no annotations, and an output schema, the description is too sparse to fully equip an agent. It does not explain how to specify the deck, the target path, or the include_media flag, nor does it mention path conventions or required permissions. The presence of an output schema reduces the need to describe return values, but the input semantics remain underspecified, making the description incomplete for correct 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?

Schema description coverage is 0%, so the description must compensate for all parameters. It mentions the three format types, which partially explains the 'format' parameter, but it does not clarify 'deck_name', 'target_path', or 'include_media'. The description adds minimal semantic value beyond what the schema already provides via names, types, and defaults, leaving the agent to guess the exact meaning of these inputs.

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

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

The description states a specific verb ('Export') and resource ('a deck'), and lists three concrete output formats (.apkg, .colpkg, JSON). This clearly differentiates it from sibling tools, none of which perform export functionality, so an agent can immediately identify its unique purpose.

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

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

The description implicitly indicates this is the export tool, but it does not explicitly state when to use it over alternatives. However, since no sibling tool offers export capabilities, the usage context is clear by exclusion. The description could mention typical use cases like backup or migration, but it's not necessary given the tool's uniqueness.

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

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

With no annotations provided, the description must carry the full burden of behavioral disclosure. It only states 'get', implying read-only, but fails to explain the output_file parameter's side effects (e.g., writing statistics to a file) or any environment prerequisites such as an open collection. This leaves significant behavioral uncertainty.

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

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

The description is a single efficient sentence that leads with the main action and the key statistics. It's concise and well-structured, though it omits the parameter explanation—a critical failure, but conciseness itself is strong.

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

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

Given that there are no annotations and the parameter has 0% schema coverage, the description is far from complete. An agent cannot invoke the tool correctly without understanding output_file. The high-level purpose is clear, but the operational details necessary for correct invocation are missing.

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

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

The sole parameter output_file is completely undocumented in both the schema and the description (schema coverage 0%). The agent has no way to know its purpose, whether it's optional, or what formats are accepted. The description should have at least mentioned that statistics can be saved to a file if output_file is provided.

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

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

The description clearly identifies the verb 'get' and the resource 'collection statistics', and enumerates specific metrics (total notes, cards, new/due cards, deck breakdown). However, it doesn't contrast with sibling tools that also return counts (e.g., search_notes), so it doesn't fully 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?

There is no guidance on when to use this tool versus alternatives. It doesn't mention that it's a read-only overview, or that specific deck details might come from list_decks. The agent receives no context to decide between this and other tools.

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

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

With no annotations provided, the description must carry the full burden of behavioral disclosure. It implies a read operation, but it does not disclose potential side effects from the optional 'output_file' parameter (e.g., writing to disk), nor any authentication requirements or error conditions. The behavior is only minimally characterized.

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

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

The description is a single, well-structured sentence that is front-loaded with the action and resource. There is no wasted wording, and it is appropriately concise for a simple retrieval 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?

Although an output schema exists (so return format is covered), the description is incomplete for correct invocation. It fails to explain the 'output_file' parameter, which is crucial for the agent to know whether to provide a value and what the consequences are. The description also omits any mention of prerequisites or error handling, making it insufficient for fully autonomous use.

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

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

The schema has 0% description coverage, so the description must compensate. It only implicitly defines 'note_id' as the identifier (matching the phrase 'by its ID'), but it completely ignores the 'output_file' parameter—its purpose, format, or effect. This leaves the agent without enough information to correctly set the optional 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 (retrieve) and the resource (note by its ID), which distinguishes it from sibling tools like search_notes or add_note. However, 'complete information' is somewhat vague and could be more specific about what fields are included, but the core purpose is unambiguous.

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

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

There is no guidance on when to use this tool versus the many note-related siblings (e.g., search_notes, update_note). The description does not mention any exclusions or alternatives, leaving the agent to infer usage from the name alone. This is insufficient for a tool in a large ecosystem.

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

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

With no annotations provided, the description carries the full burden of behavioral disclosure. It only says 'get detailed schema information,' which implies a read operation, but it does not explicitly confirm read-only status, mention error behavior (e.g., if the notetype doesn't exist), or describe what 'detailed schema information' includes. This is minimal disclosure.

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

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

The description is a single sentence, concise and front-loaded, with no filler words. However, its brevity borders on under-specification; while it is efficient, it omits critical details that would earn 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 tool is simple and has an output schema, so return values are partially covered. Yet the description does not mention error handling, the read-only nature (with no annotations to cover that), the purpose of the output_file parameter, or what constitutes 'detailed schema information.' This is incomplete for an agent to use correctly without significant 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?

Schema description coverage is 0%, and the description itself does not explain either parameter. The required 'notetype_name' is only implied by 'specific notetype,' and 'output_file' is entirely unexplained. The agent would have to guess what output_file does, which is a severe gap given the lack of schema descriptions.

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

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

The description states a specific verb ('get') and resource ('detailed schema information about a specific notetype'), making the operation clear. It distinguishes from list_notetypes implicitly by focusing on a single notetype, but it does not explicitly name the sibling or the distinction, so it falls short of a 5.

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

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

There is no guidance on when to use this tool versus alternatives like list_notetypes. The description does not mention any context, prerequisites, or conditions for selection, leaving the agent to infer usage on its own.

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

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

No annotations are provided, so the description carries the burden of behavioral disclosure. It specifies that the tool returns deck IDs and card counts, which is useful. However, it does not mention side effects, ordering, pagination, or performance characteristics. For a simple read-only listing, this is adequate but not rich.

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

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

The description is a single, front-loaded sentence with no redundancy. It states the action and the result content efficiently. The missing parameter explanation is a completeness issue, not a conciseness one, so it scores high here.

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

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

The tool is straightforward with one optional parameter, but the parameter's purpose is entirely undocumented. The output schema exists, which may explain the response, but the input parameter remains unexplained. There is also no usage guidance regarding alternatives. These gaps prevent an agent from correctly invoking the tool with the output_file argument.

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 only parameter, output_file, is not mentioned in the description at all. The schema provides a type and default but no description. With 0% schema description coverage, the description must compensate, but it does not. An agent cannot infer what output_file does, making this a critical 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?

The description clearly states a specific verb (List) and resource (all decks in the Anki collection) and specifies the output content (IDs and card counts). It distinguishes from siblings like create_deck or delete_deck by implying a read-only enumeration.

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 vs alternatives. The name and description imply a listing operation, but there is no mention of conditions, exclusions, or alternative tools. The purpose is distinct enough that usage is implied, but no direct 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?

No annotations are provided, so the description carries the full burden for behavioral transparency. It mentions the output ('their fields, and types') but does not disclose whether this is read-only, if there are side effects, any performance implications, or error behavior. The description adds minimal behavior beyond the basic purpose.

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 unnecessary words. It states the core action and outputs efficiently. It is maximally concise while still conveying the essential purpose.

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

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

The tool is a simple list operation, but the single parameter 'output_file' is entirely undocumented in both the schema and the description. There is no indication of what the output_file controls, nor any usage guidance or behavioral notes. Without this, an agent cannot correctly invoke the tool beyond making a default call.

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 one parameter, 'output_file', with no description, and schema description coverage is 0%. The description does not mention this parameter at all, so an agent receives no explanation of what it controls or how to use it. The description completely fails to compensate for the lack of schema 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 states a specific action ('List all available notetypes') and names the resource ('notetypes (models) in the collection'), as well as what is returned ('their fields, and types'). This clearly distinguishes it from sibling tools like 'get_notetype_info' by emphasizing 'all' as opposed to a specific notetype.

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 instead of alternatives. It does not mention any sibling tools, conditions, or exclusion criteria. An agent must infer that it is for retrieving a full list, but there is no explicit 'when to use' or 'when not to use' context.

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

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

With no annotations, the description must disclose behavioral traits. It does mention the disk-write side effect, which is important, but it is vague about implications (e.g., overwriting, file creation, or behavior when output_file is null). A more explicit disclosure of side effects and prerequisites would raise the score.

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

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

The description is a single sentence with no filler, front-loading the core action and then the side effect. Every word adds value, and it is appropriately sized for a simple tool.

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

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

The tool is simple with one optional parameter and an output schema (not shown but indicated). The description covers the purpose and side effect, and the output schema handles return values. It could improve by clarifying the null case, but it is otherwise complete for the tool's complexity.

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

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

Schema description coverage is 0%, so the description must compensate. The phrase 'writing full tag array to disk' clarifies that output_file is the file where the tags are written, giving meaning to the otherwise opaque parameter. However, it does not specify behavior when output_file is null, leaving some ambiguity.

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

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

The description clearly states the action ('List all unique tags across the collection') and adds a concrete side effect ('writing full tag array to disk'). The resource (tags) is distinct from sibling list tools like list_decks and list_notetypes, so an agent can easily identify the tool's scope.

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

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

The description provides no explicit when-to-use guidance or comparisons with alternatives. While the purpose itself implies usage (listing tags), it does not mention exclusions (e.g., 'for modifying tags use add_tags_to_notes') or conditions (e.g., 'when you need a full tag list'). This leaves the agent to infer context from sibling names 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?

With no annotations, the description carries full responsibility for behavioral disclosure. It only says tags are removed; it does not mention side effects (e.g., permanent modification of notes), whether the operation is atomic, what happens if tags or notes are not found, or the role of output_file. This is a significant omission for a mutation tool.

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

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

The description is a single, concise sentence with no redundant phrasing. It front-loads the primary action and mentions both input modes. However, it lacks structured detail that could be added without becoming verbose, such as a brief note on parameter usage.

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 four optional parameters and likely supports multiple modes (tags, note_ids, file-based). The description does not explain how these modes combine or exclude each other, nor does it clarify the purpose of output_file. With no output schema shown (though indicated), an agent lacks essential information to correctly invoke the 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 0%, so the description must explain parameter meanings. It vaguely references 'argument lists or a JSON file' but does not clarify how tags, note_ids, input_file, and output_file relate. For example, are tags and note_ids alternatives? What is the expected JSON structure? The description adds minimal value beyond parameter names.

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

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

The description states a clear action (remove tags) on a specific resource (notes) and mentions bulk operation with two input sources (argument lists or a JSON file). It is specific enough to distinguish from sibling tag tools like list_tags and add_tags_to_notes, though it lacks explicit differentiation like 'as opposed to add_tags_to_notes'.

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 about when to use this tool versus alternatives. The description implies the use case (removing tags) but does not state prerequisites, exclusions, or the relationship to add_tags_to_notes. An agent would have to infer appropriate usage.

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

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

No annotations are provided, so the description carries the full burden of behavioral disclosure. It does reveal the side effect of renaming child subdecks, which is useful, but it omits critical behavior: whether the operation is reversible, what happens if the deck ID does not exist, any permission requirements, and the nature of the output. This is a mutation tool that remains under-specified.

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, tight sentence with zero fluff. It front-loads the action and scope, making it instantly parseable. All words contribute value, and it avoids redundancy with the schema or annotations. This is exemplary 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?

Given the tool has 3 parameters, no annotations, and an output schema, the description is insufficient. It explains the core action but does not clarify parameter usage, expected side effects, error conditions, or the return value, even though an output schema exists. An agent cannot confidently invoke this tool correctly 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?

Schema description coverage is 0%, so the description must compensate by explaining parameters. It indirectly clarifies 'deck_id' (by deck ID) and implies 'new_name' (rename), but it does not address the 'output_file' parameter at all, which is optional and nullable. The description provides only partial parameter semantics and leaves a required-to-clarify field undocumented.

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 'Rename' and the resource 'an existing deck', and adds the scope 'and its child subdecks' with the identifier 'by deck ID'. This distinguishes it from create/delete operations, though it does not explicitly differentiate from the sibling 'change_deck', which could overlap in intent. The purpose is unambiguous for an agent.

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

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

The description implies when to use the tool: when you need to rename a deck (and its subdecks). However, it provides no explicit context, prerequisites, or exclusions, and does not mention alternative tools such as 'change_deck' for related modifications. Usage guidance is implicit rather than actionable.

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 mentions returning results 'to disk', which is a significant side effect (writing a file), but does not clarify whether the function returns anything in response, its read-only nature, or any other behavioral traits like rate limits or permissions. The term 'returning ... to disk' is ambiguous—does it write a file or return a path? This lacks transparency.

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

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

The description is a single concise sentence that front-loads the core action and result. It is efficient and easy to read, though it might be slightly too sparse given the tool's complexity. No wasteful 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?

With three parameters, no schema descriptions, and no annotations, the description is severely incomplete. It does not explain the Anki browser syntax, the output file format, the meaning of the limit, or the return value (especially since it says 'to disk' but an output schema exists). An agent cannot safely invoke this tool without consulting external 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?

The schema description coverage is 0%, so the description must compensate by explaining parameters, but it does not. It does not explain what 'query' should contain beyond 'Anki browser syntax', nor what 'limit' controls, nor how 'output_file' is used (the phrase 'to disk' hints at it but without specifics). The description adds almost no value beyond the schema field names.

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

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

The description clearly states the verb 'Search' and the resource 'cards', specifies the query syntax (Anki browser syntax), and lists the returned data (queue status, due dates, intervals). It is distinguishable from sibling tools like search_notes because it targets cards explicitly, though it doesn't name sibling tools.

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

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

There is no explicit guidance on when to use this tool versus alternatives like search_notes or other card-related tools. The description implies it's for searching cards, but does not state conditions, exclusions, or alternative usage scenarios. The agent is left to infer when this tool 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?

With no annotations present, the description must carry the full burden of behavioral disclosure. It does disclose a key side effect: writing full matched cards/fields to disk. However, it omits details such as whether Anki notes are modified (read-only on Anki), file format, overwriting behavior, or required permissions. The disclosure is partial, adding some transparency but leaving notable gaps.

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

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

The description is a single sentence that is lean and front-loaded. It conveys the action, the syntax used, and the side effect in a compact manner, with no redundant words or filler. It is concise without sacrificing essential 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 there being an output schema, the description is too brief for a tool with three parameters and a disk-write side effect. It lacks guidance on the output file format, the expected query structure, how limits interact with results, and any caveats about writing to disk. An agent would likely need to inspect the schema and output schema more deeply to call the tool correctly, indicating incomplete contextual coverage.

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

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

Schema description coverage is 0%, so the description must compensate by explaining parameters. It does clarify that 'query' uses Anki browser syntax, which is meaningful and not evident from the schema alone. However, it does not explain the 'limit' parameter or the 'output_file' parameter beyond implying it is the disk destination. The description adds modest value but does not fully document all parameters.

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

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

The description clearly states the action (search) and resource (notes), and specifies the use of Anki browser syntax for the query. The mention of 'writing full matched cards/fields to disk' also distinguishes this tool from 'search_cards' by indicating a disk-writing behavior and a focus on notes rather than cards. However, it does not explicitly reference sibling alternatives, so it misses the top score for explicit 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 like 'search_cards'. There is no mention of prerequisites, limitations, or scenarios where this tool is preferred. The description implies a specific use case (searching notes with browser syntax and saving results) but does not offer explicit when-to-use or when-not-to-use instructions.

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

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

No annotations are provided, so the description carries the full burden of behavioral disclosure. It only states that the file is stored 'directly from local disk', implying a read from the local filesystem, but it does not disclose side effects (e.g., whether existing media with the same name is overwritten, whether Anki needs to be running, or what permissions are required). For a write operation with no annotation coverage, this is a significant gap.

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

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

The description is a single, concise sentence that front-loads the core action and destination. It contains no redundant words or filler, making it efficient and easy to parse. However, it is so brief that it borders on under-specification; still, for conciseness and structure, it earns a 4.

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 annotations, no parameter descriptions, and the description is minimal, the overall context is incomplete. The agent lacks critical details such as error handling, overwrite behavior, naming rules, or whether the targeted media storage is already accessible. A simple tool like this still needs more behavioral context to be called correctly in varied scenarios.

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

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

The description does not mention either parameter (source_path or target_name) at all. With schema description coverage at 0%, the description fails to add any meaning beyond the raw schema names. The agent is left to infer the semantics of 'source_path' and 'target_name' purely from their names, without clarification on formats, constraints, or defaults. This is insufficient compensation for the lack of schema descriptions.

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

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

The description clearly states the action (store), the resource (media file), the source (local disk), and the destination (Anki's media storage). It names specific media types (image, diagram, audio) and is easily distinguishable from sibling tools that deal with decks, notes, or tags. This is a specific and unambiguous purpose.

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

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

The description provides no guidance on when to use this tool versus alternatives, nor does it mention any exclusions or prerequisites. While it is clear this is the only media-storage tool among siblings, the lack of explicit context or routing leaves the agent without criteria for when to choose it. No alternatives are named or contrasted.

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

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

No annotations are provided, so the description carries the full burden. It discloses the action (suspend) but omits any side effects, reversibility, or what happens to the cards after suspension. For a mutating operation with zero annotation coverage, this is a significant gap.

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

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

A single sentence that front-loads the action and then lists the selection methods. No wasted words; it is appropriately concise for the complexity it conveys.

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

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

With no annotations and an output schema present but not described here, the description leaves out key operational details: how selectors interact, whether cards are matched by any or all criteria, and the purpose of the output file. For a tool with 5 optional parameters, this is insufficiently complete.

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

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

Schema coverage is 0%, so the description must compensate. It names four of the five parameters (query, card_ids, note_ids, input_file) as selection methods, adding meaning beyond the raw schema. However, it does not explain how these combine, take precedence, or what output_file does, leaving the fifth parameter unexplained.

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 'Suspend' and the resource 'cards', and specifies the selection methods (by card IDs, note IDs, search query, or input file). It distinguishes from the sibling 'unsuspend_cards' by the opposite action, leaving no ambiguity about its purpose.

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

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

The phrase 'from active review queues' provides some context, but there is no explicit guidance on when to use this tool versus alternatives. It does not mention exclusions or prerequisites, and the sibling 'unsuspend_cards' is only implied as the inverse rather than explicitly referenced.

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 behavioral burden. It discloses the core effect (moving cards to active review queues) but omits any mention of permissions required, reversibility, validation of inputs, or what happens if cards are not suspended. It does not contradict any annotations (none provided) but adds only minimal behavioral context beyond the verb itself.

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 communicates the action and the primary input modes. No filler, no repetition, and the most essential information (what it does) comes first.

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 an output schema exists and the tool's behavior is relatively simple, the description leaves gaps: it does not explain how multiple selection criteria interact, what output_file is for, or any prerequisites (e.g., cards must currently be suspended). The agent would need to infer parameter usage from the schema alone, which lacks descriptions. The description is adequate but incomplete.

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

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

Schema coverage is 0%, so the description must clarify all parameters. It explicitly mentions card_ids, note_ids, query, and input_file, but does not describe the output_file parameter at all. It also leaves query syntax undefined and does not explain relationships or exclusivity between parameters. This partial coverage only partially compensates for the schema's lack of descriptions.

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

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

The description clearly states a specific verb ('Unsuspend') and resource ('cards'), and specifies the action's result ('back into active review queues'). It also enumerates four distinct ways to select cards (by IDs, query, file), which distinguishes it from the sibling suspend_cards and makes its purpose unambiguous.

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

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

The description implies its use (to reverse suspension) but does not explicitly contrast with alternatives or state when not to use it. It mentions multiple selection methods but gives no guidance on precedence, combination, or when a query vs. IDs is preferable. There are no exclusions or 'use instead' references to siblings like suspend_cards.

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?

Since no annotations are provided, the description must disclose behavioral traits itself. It only states the action 'update fields and/or tags' without clarifying whether the update is a full replacement or a merge, what happens to existing values, whether the operation is reversible, or how output_file affects the operation. These are significant gaps for a mutation tool.

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

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

The description is a single, efficient sentence that wastes no words. It front-loads the core action and target resource while keeping the instruction brief and unambiguous.

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

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

The tool has three parameters with zero schema description coverage, and the description fails to explain the required JSON file format, the semantics of output_file, or how updates interact with existing note data. An output schema exists, so return values are covered, but the missing usage context makes the definition incomplete for a mutation tool.

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

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

The schema description coverage is 0%, so the description must compensate for the lack of parameter documentation. It hints that input_file contains a JSON file, but does not explain the JSON structure, expected keys, or the role of output_file. The description adds only a vague notion that the input provides update data, leaving agents to infer the 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?

The description states a specific verb (update) and resource (existing note), and specifies the scope (fields and/or tags). It plainly distinguishes from sibling tools like add_note (creation) and delete_notes (removal), and is the only tool in the list dedicated to updating an existing note.

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

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

The description provides no explicit guidance on when to use this tool versus alternatives such as add_note or remove_tags_from_notes. It does not mention conditions like 'use when you have a note_id and want to modify its content or tags', nor does it describe any prerequisites or exclusions.

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