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

There are no annotations, so the description must carry the burden of behavioral disclosure. It only states the mutation itself and says nothing about side effects, idempotency, whether duplicate labels are rejected, or what happens if the note or label does not exist.

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

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

The description is one short, front-loaded sentence with no filler. It is concise, though slightly terse; it provides the core operation but sacrifices useful context for brevity.

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

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

While the tool is simple, the absence of annotations and parameter descriptions leaves important context missing, such as preconditions and behavior on duplicate labels. The output schema may cover return values, but the description does not make the tool complete enough to invoke confidently.

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, and the description adds no clarification beyond the parameter names. It does not explain that note_id must reference an existing note, that label_id must reference an existing label, or how those IDs should be obtained.

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

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

The description clearly states a specific verb and resource: adding a label to a note. It is immediately understandable and distinguishable from the remove_label_from_note sibling by the opposite direction of action, though it does not explicitly name or contrast any sibling.

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 related tools like create_label, list_labels, or remove_label_from_note. There are also no stated prerequisites, such as the note and label already existing or how to obtain their IDs.

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 behavioral disclosure burden. It states a mutation occurs, but does not explain append behavior, whether checked defaults to false, failure modes, permissions, or reversibility.

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

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

The description is a single clear, front-loaded sentence with no filler. It is appropriately concise, though it sacrifices useful detail.

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

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

For a mutation tool with no annotations and zero schema descriptions, the description is incomplete. It omits prerequisites such as the note being a checklist, behavior when the note does not exist, and the role of the checked parameter. The output schema covers return values, so that is not the gap.

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

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

Schema description coverage is 0%, so the description needs to compensate. It provides only a slight relational hint that an item is added to a checklist note, but it does not explain the meaning of note_id, text, or checked beyond their names.

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

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

The description uses a specific verb and resource: 'Add an item to a checklist note.' It clearly identifies the operation and distinguishes it from sibling tools like update_list_item and delete_list_item.

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 alternatives such as update_list_item, delete_list_item, or create_list. There are no preconditions, exclusions, or context cues to help the agent choose this tool correctly.

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 core toggle behavior but does not explain the effects of archiving (e.g., visibility, retrieval, reversibility beyond the unarchive option), permissions, or any side effects. There is no contradiction with annotations because none exist.

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

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

The description is a single front-loaded sentence with no filler. It is appropriately concise for a simple two-parameter tool, though its brevity prevents it from providing richer routing or usage context.

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 core call is fully specified: note_id and archived are inferable, and an output schema exists, so return-value documentation is not required. The main gap is situational context—how archiving relates to trashing, deleting, or restoring notes—which matters given the large sibling set.

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 must compensate. 'Archive or unarchive' maps usefully to the archived boolean parameter and identifies note_id as the target, but it does not explicitly document the default true value or the archived=false -> unarchive mapping. Some semantics are left to inference.

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 ('Archive or unarchive') and a clear resource ('a note'). It distinguishes this tool from deletion, trashing, and pinning, though it does not explicitly contrast it with sibling tools like restore_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?

No guidance is provided about when to use this tool instead of alternatives like trash_note, delete_note, or restore_note. The description relies entirely on the tool name and user inference, with no exclusions, prerequisites, or decision context.

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

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

No annotations are provided, so the description carries the full burden of behavioral disclosure. The description only states the action but does not mention side effects, uniqueness constraints, naming rules, or return behavior beyond what the action itself implies.

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 with no redundant words and front-loads the core action. It is appropriately short for a simple one-parameter tool, though some additional context would make it more useful.

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 trivial one-parameter create operation with an output schema, the description is minimally viable. However, it lacks usage context, behavioral details, and any mention of when this tool should be selected over related label operations.

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 does not compensate by explaining the 'name' parameter's constraints, format, or meaning beyond the schema's own 'Name' title. It provides minimal interpretability but no added semantic value.

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

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

The description explicitly states the action ('Create') and the resource ('a new label'), which is specific and unambiguous. It also distinguishes this tool from siblings such as delete_label and list_labels by indicating an additive operation on the label resource.

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

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

There is no guidance about when to use this tool versus alternatives like list_labels, delete_label, or even create_note and create_list. The intended context is only implied by the name and description, not stated explicitly.

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 carried the burden and it discloses two non-obvious behaviors: the automatic 'keep-mcp' safety label and the default unchecked state of items. It does not go into permission requirements or what happens if items is null, but the provided side-effect information is meaningful.

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

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

Three short sentences, each earning its place: the action, the autoatic label side effect, and the item format/default state. The most important purpose information is front-loaded in the first sentence.

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

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

For a two-parameter create tool with an output schema, the description covers the core purpose, a key hidden side effect, and the main parameter semantics. It is slightly incomplete only in not routing between checklist and regular note creation, but nothing required to invoke it correctly is missing.

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

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

Schema description coverage is 0%, so the description must compensate; it explains that items are a list of strings and start unchecked, which adds real meaning beyond the schema. It does not describe the required title parameter, leaving that property solely to 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 opens with 'Create a new checklist note,' which names a specific verb and resource, and the checklist qualifier separates it from the regular create_note sibling. The auto-applied 'keep-mcp' safety label adds another distinct behavioral marker.

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 'Create a new checklist note' implies the tool is for checklist creation, but it never names alternatives such as create_note for regular notes or add_list_item for later additions. There is a clear implied use case but no explicit when-to-use or when-not-to-use guidance.

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

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

With no annotations provided, the description carries the burden of behavioral disclosure. It does disclose a meaningful non-obvious side effect: automatically applying the 'keep-mcp' safety label. This is valuable context an agent would not otherwise know.

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 short sentences with no filler. The core action is stated first, and the important automatic label behavior is added second. Every word earns its place.

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

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

For a simple two-parameter create tool with an output schema, the description covers the core action and a hidden behavioral effect. Missing usage guidance is minor here because the purpose is clear, but the lack of parameter context prevents a perfect score.

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 should compensate by explaining the title and text parameters. It does not, beyond the implicit hint in 'text note.' The schema provides names and required status, but the description adds no parameter-level detail.

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

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

The description uses a specific verb ('Create') and resource ('new text note'), clearly distinguishing this from sibling tools like create_list and update_note. The action and object are unambiguous.

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

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

The description gives no guidance on when to use this tool versus alternatives such as create_list or update_note. It does not state prerequisites, exclusions, or decision criteria.

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 transparency burden. It usefully warns that the operation is globally destructive and requires unsafe mode, but it does not clarify whether deletion is irreversible or what happens to notes that use the label, leaving some behavioral ambiguity.

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

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

The description is two tight sentences with no filler: the action is front-loaded and the critical safety caveat follows immediately. Every word earns its place.

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

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

For a simple one-parameter tool with an output schema, this is mostly adequate, but it omits important context for a destructive operation: the full scope of destruction, irreversibility, or side effects on associated notes. A short additional sentence would make it complete.

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

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

The single parameter label_id is self-explanatory from its name and schema title, but the description adds no parameter-level guidance. Since schema description coverage is 0%, the description should compensate, and it does not address how to obtain the ID or any format expectations.

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 ('Delete') and a clear resource ('a label'). It is unambiguous and distinguishes this tool from siblings such as remove_label_from_note or delete_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 an explicit prerequisite: UNSAFE_MODE=true, and explains why ('globally destructive'). This gives clear context about when the tool may be invoked, though it does not explicitly name alternatives such as remove_label_from_note.

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. While 'Remove' conveys that the operation mutates the note, it does not state whether deletion is permanent, whether the item is recoverable, how the parent note is affected, or what error conditions may arise.

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

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

The description is a single, efficient sentence that immediately states the action and target. There is no filler or redundant restatement of the tool name.

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

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

For a simple two-parameter remove operation, the core action is conveyed and an output schema exists, so the description is minimally adequate. However, it lacks usage guidance and sufficient parameter semantics, leaving an agent to infer details that should be explicit.

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 the absence of parameter documentation. It loosely maps 'item' to item_id and 'checklist note' to note_id, but it never explains the relationship between the two IDs or where item_id should be obtained from.

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, 'Remove', on a specific resource, 'an item from a checklist note'. This clearly distinguishes it from sibling tools like add_list_item and update_list_item, and adds the checklist-note context beyond what the name alone provides.

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

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

The description implies the tool should be used when an item needs to be removed from a checklist note, which is clear enough. However, it gives no explicit guidance about when not to use it or how it relates to siblings such as add_list_item, update_list_item, or trash_note.

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

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

With no annotations, the description carries the burden of disclosing behavioral traits. It states the permanent/destructive nature and the UNSAFE_MODE requirement, which are critical for safe invocation. It could add more about cascading effects, but the most important safety-related behavior is disclosed.

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 with no wasted words. The primary action is front-loaded, followed by the safety requirement and the explicit alternative. Every sentence 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?

This is a simple one-parameter destructive tool with no annotations and an output schema present. The description covers the purpose, the key prerequisite, and the alternative for reversible deletion. Nothing essential is missing 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%, but the single parameter note_id is semantically self-evident and is reinforced by the description's reference to 'a note.' For a one-parameter tool, the description provides enough context to understand what the parameter identifies.

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 and resource: 'Permanently delete a note.' It clearly distinguishes itself from the related sibling trash_note by emphasizing the permanent nature of the operation.

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

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

Usage context is explicit: it requires UNSAFE_MODE=true, and it explicitly directs agents to trash_note for reversible deletion. This gives clear guidance on when to use this tool versus the alternative.

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, but it only says 'Search notes with optional filters. Returns matching notes.' It does not mention default filter scope (e.g., whether trashed or archived notes are included), query matching semantics, pagination, auth requirements, or sort order. These are significant gaps for a search 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 very short and front-loaded with the core action, containing no filler or repetition. It is appropriately concise, though the extreme brevity means it sacrifices useful behavioral and parameter guidance.

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 six filter parameters and no annotations, the description is incomplete. It does not clarify filter combination logic (AND/OR), default values when filters are omitted, pagination, or what fields are searched by 'query'. The output schema may define the return shape, but the input behavior is underspecified.

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 does not compensate by explaining any parameter. It only refers generically to 'optional filters' without describing what query matches against, what colors/labels expect (IDs? names? hex codes?), or how pinned/trashed/archived interact. Some parameter names are self-explanatory, but key semantics like 'query' are left 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 verb ('Search') and a resource ('notes'), and says it returns matching notes, so an agent knows the basic operation. It does not, however, differentiate this tool from siblings such as get_note or list_note_media, since no alternative is mentioned.

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 get_note (for a known note ID) or list_note_media (for media). The phrase 'optional filters' implies a search use case, but no explicit when-to-use or when-not-to-use conditions are provided.

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

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

No annotations are provided, so the description carries the burden of disclosing behavior. 'Get' clearly indicates a read-only operation, but the description says nothing about not-found behavior, authentication, or edge cases. For a simple retrieval tool this is acceptable 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 sentence with no filler. The key qualifier 'by its ID' is front-loaded, and the wording is appropriately sized for the tool's simplicity.

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

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

With only one required parameter, low complexity, and an output schema presumably describing the return value, the description is mostly sufficient for basic invocation. However, it lacks usage alternatives and any behavior around missing or invalid note IDs, leaving it merely adequate rather than 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 has one required parameter, note_id, and description coverage is 0%. The description only restates that the note is retrieved 'by its ID,' which adds no meaning beyond the schema's own 'Note Id' property title. It does not clarify ID format, valid values, or behavior for invalid IDs.

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

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

The description uses the specific verb 'Get' with the resource 'note' and qualifies it as 'by its ID,' making it clear this is a direct single-note fetch. It does not explicitly contrast it with siblings like find or list, so it is clear but not fully differentiated.

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?

'By its ID' implies the tool should be used when the caller already knows the note identifier, but there is no explicit when/when-not guidance or mention of alternative tools. The usage context is reasonably implied for a simple get-by-id operation, but not fully articulated.

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 itself must convey behavioral traits. The verb 'List' signals a read-only operation, and 'all labels' indicates no filtering or hidden scope. It does not mention pagination, rate limits, or authentication, but for a zero-parameter listing tool with an output schema, the description adequately reveals the core behavior.

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

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

The description is a single, concise sentence that immediately states the action and scope. There is no redundant information or filler.

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

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

Given the tool has no parameters and an output schema exists, the description provides all necessary context for an agent to invoke it correctly. The simplicity of the operation means no additional prerequisites, exclusions, or alternatives are essential.

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

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

The tool has zero parameters, so the baseline is 4. The description adds no parameter detail, but none is needed; 'List all labels' fully conveys what the call does without requiring any 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 clear verb ('List') and resource ('all labels in Google Keep'), making the tool's purpose unambiguous. It also naturally distinguishes this tool from siblings like create_label and delete_label by focusing on enumeration rather than mutation.

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

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

The description clearly indicates this tool is for retrieving all labels, which is the correct context for use. It does not provide explicit 'when not to use' or alternative tool references, but given zero parameters and a straightforward listing operation, the usage context is clear.

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. The word 'List' implies a read-only operation, which is useful, but the description does not explicitly disclose side effects, permissions, or any special behavior regarding media ownership or access. The output schema covers the return shape, but safety and behavioral context remain thin.

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, unambiguous sentence with no filler. Every word contributes to understanding the tool's 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?

For a simple tool with one self-evident required parameter and an output schema, the description is nearly complete for invocation. It could be strengthened by explicit read-only confirmation or guidance on how this relates to get_note, but nothing essential to making the call is missing.

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

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

The only parameter, note_id, is self-descriptive, and the phrase 'on a note' maps clearly to it despite 0% schema description coverage. However, the description does not add any detail about expected format, constraints, or how the ID must be obtained, leaving the schema's bare string type to carry all meaning.

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 object ('media attachments') with a clear scope ('on a note'). This distinguishes it from sibling tools like get_note or update_note, none of which focus on media attachments.

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, no exclusions, and no context about prerequisites. An agent must infer the use case entirely from the tool name and the action verb.

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

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

With no annotations, the description carries the full burden for behavioral disclosure, but it only restates the core action. It does not mention idempotency, effect on note ordering/visibility, behavior on archived or trashed notes, invalid note_id handling, or what response is returned. No contradiction with annotations because none are provided.

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 six words and fully front-loaded. There is no filler, and for a simple two-parameter toggle the size is appropriate; all other gaps are issues of content rather than structure.

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

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

Given the low complexity and presence of an output schema, the description does not need to explain return values. It is minimally viable: an agent can infer the basic call from the name, schema, and short description. However, missing behavioral details and usage routing 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?

Schema description coverage is 0% and the description adds no explicit parameter meaning beyond the phrase 'Pin or unpin'. It does not clarify that pinned=false means unpin or explain note_id format/constraints. The schema's titles and default for pinned provide some self-evident meaning, keeping this above 1, but the description does not compensate for the missing 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 ('Pin or unpin') and resource ('a note'), making the tool's purpose immediately clear. It is not a tautology and the operation is distinct enough from siblings like archive_note and trash_note that an agent can identify it, though it does not explicitly contrast with update_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?

No when-to-use guidance, preconditions, or alternatives are provided. The description gives no indication of when pinning is appropriate or how this differs from update_note or other note operations. Usage context must be inferred entirely from the tool name.

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

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

With no annotations, the description must disclose behavior on its own. It accurately states the core mutating action, but it does not clarify whether the label is merely disassociated from the note or deleted, nor what happens if the label is not already attached. This is a minimal but not misleading 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?

A single, clear, front-loaded sentence contains exactly the necessary information with no filler. It earns its place efficiently.

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

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

For a two-parameter tool with an output schema, the description covers the basic operation but lacks guidance on edge cases, side effects, and alternative tool selection. It is adequate for straightforward use but not richly contextual.

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 does not enumerate or explain note_id and label_id explicitly. However, the phrase 'from a note' plus the parameter names makes the roles of the two IDs clear enough for a simple operation.

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 ('Remove') and a specific resource ('a label from a note'). It is immediately distinguishable from sibling tools like add_label_to_note and delete_label, so the agent knows exactly what this tool 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?

No guidance is provided about when to use this tool versus alternatives such as delete_label or add_label_to_note. The intended use is inferable from the name, but the description does not explicitly state when-not or mention any prerequisites or edge conditions.

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

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

With no annotations, the description carries the behavioral burden. It discloses the key limitation that only trashed notes can be restored and permanently deleted ones cannot. It does not detail error behavior or response semantics, but for a simple restore operation the core behavior is clearly communicated.

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

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

Two short sentences with no filler. The main action is front-loaded, and the critical restriction is added clearly in the second sentence.

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

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

For a single-parameter tool with an output schema, the description covers the essential precondition and limitation. The main gap is the lack of note_id semantics, but the operation is simple enough that the description plus schema is mostly sufficient.

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

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

The only parameter, note_id, has no schema description and the tool description does not explain its format, source, or how to identify the target note. The meaning is largely inferable from the name, but the description adds no explicit parameter context despite the 0% schema description coverage.

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

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

States a specific verb, 'Restore', and a specific resource, 'a note from trash'. It also explicitly scopes the operation to trashed notes and excludes permanently deleted ones, which distinguishes it from tools like delete_note and trash_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?

Gives clear when-to-use guidance: restore a trashed note. It also gives an explicit exclusion: does not work on permanently deleted notes, so an agent knows not to attempt it in that case.

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

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

With no annotations, the description carries the behavioral burden. It discloses the mutation effect and enumerates valid color values, which is useful. However, it does not mention invalid-color behavior, permissions, idempotency, or what happens if the note does not exist, leaving some 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 two short sentences, front-loaded with the action and immediately followed by a high-value list of allowed values. Every sentence earns its place with no redundancy.

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

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

For a simple two-parameter setter with an output schema present, the description is largely complete: it states the action and all valid color values. It could be stronger with usage guidance and error/authorization notes, but the core invocation information is present.

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

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

The schema provides only field names and types with no descriptions, so the description's enumeration of valid colors adds substantial meaning for the 'color' parameter. It does not describe 'note_id' format, but that parameter is self-explanatory and the color enum is the critical semantic content.

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 ('Set') and resource ('note') and identifies the exact attribute being modified ('color'). It is clear and distinguishable from generic note operations, though it does not explicitly name sibling tools to differentiate from.

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 update_note, or any context about prerequisites or constraints. The description only states what the tool does, leaving usage decisions entirely to inference.

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

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

With no annotations provided, the description carries the burden of disclosing behavior. It does disclose the key trait that the operation is reversible, which is important for a mutation tool. It does not mention side effects like where the note goes or if it disappears from normal list, but the reversibility statement provides meaningful behavioral context.

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

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

The description is two tightly written sentences with no filler. The primary action is front-loaded, and the second sentence adds the essential caveat about reversibility. Every word earns its place.

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

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

For a simple one-parameter mutation tool with an output schema present, the description covers the core action and reversibility. It falls short on differentiating from closely related siblings like delete_note and archive_note, which is a meaningful gap given the sibling 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 should compensate by explaining how to identify the note. The description only says 'a note' and never references the note_id parameter, adding no semantic value beyond the schema's own 'Note Id' title. The single parameter is simple and inferable, but the description does not explicitly connect it to the operation.

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 ('Move a note to trash') and the resource (note), making the tool's function immediately understandable. It references restore_note as the reversal path, which positions trash as a non-permanent state, though it does not explicitly contrast with the sibling tool delete_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 implies usage context by noting reversibility via restore_note, which suggests this is for temporary removal rather than permanent deletion. However, it does not explicitly state when to prefer trash_note over archive_note or delete_note, leaving the decision among sibling tools to inference.

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

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

No annotations are provided, so the description carries the full burden of behavioral disclosure. It only states the basic mutation ('Update') and which fields are affected; it does not disclose permission requirements, whether the update is partial, idempotency, error behavior, or what happens if note_id and item_id do not match.

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, front-loading the verb and the target resource. It earns its place, though there is room to add useful routing or identifier context without bloating it.

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

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

With no annotations, 0% schema coverage, and only a one-sentence description, the definition is incomplete for a tool with four parameters and required identifiers. Even though an output schema exists, the agent lacks guidance on identifiers, usage boundaries, and behavioral expectations.

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 adds meaning for text and checked by saying they are the mutable item properties, but it says nothing about note_id or item_id, which are required and ambiguous without further context such as where the IDs come from.

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 'Update', the resource ('a checklist item'), and the updatable fields ('text and/or checked state'). It is distinguishable from add and delete list item siblings, though it does not explicitly name those alternatives.

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

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

The intended use is implied: use this when you want to change an existing checklist item's text or checked state. However, the description gives no explicit guidance on when not to use it or how it relates to siblings like add_list_item, delete_list_item, or update_note.

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 carries the full burden for behavioral disclosure. It only restates the mutation and target fields without clarifying whether omitted fields remain unchanged, whether null clears a field, or what side effects occur. This leaves important behavioral ambiguity.

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

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

The description is a single, front-loaded sentence with no filler. It is efficient, though a bit too sparse to earn a 5.

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

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

This is a simple tool with three basic parameters and an output schema, so the core operation is clear enough for an agent to attempt calling it. However, missing usage guidance and unresolved partial-update/null behavior leave meaningful gaps.

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

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

Schema description coverage is 0%, so the description must compensate. It names title and text content, but adds little beyond the schema property titles and does not explain the required note_id or the meaning of null/default values. The 'and/or' phrase hints at partial updates but does not resolve semantics.

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

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

The description states a specific verb ('Update'), a distinct resource ('a note'), and the exact scope ('title and/or text content'). This cleanly distinguishes it from siblings like set_note_color, create_note, or trash_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?

No guidance is given about when to use this tool versus alternatives such as create_note, delete_note, or update_list_item. The intended context is only implied by the word 'Update', with no exclusions or alternative routing cues.

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