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 explicitly states that the content is appended or prepended and that existing content is not replaced, which is the core side effect. It also mentions 'existing note,' implying the tool does not create new notes. However, it does not cover failure scenarios or permission requirements, which are common for mutation tools.

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. It front-loads the action and includes the most important constraint ('without replacing it') immediately. Every word contributes.

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 no output schema and a fully described schema, the description plus schema provides all essential information: what to pass (path, content, mode), the operation (append/prepend), and the behavioral guarantee (no replacement). Missing are explicit error handling or note-existence checks, but the word 'existing' partially addresses this.

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

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

Schema description coverage is 100%, so all parameters are already documented. The description adds meaning by clarifying that content is 'markdown' and emphasizing the append/prepend modes. It also corrects a subtle inconsistency: the schema's content description says 'appendix at the end,' but the mode can be prepend; the description clarifies this behavior.

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

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

The description clearly states a specific verb ('Append (or prepend)') and resource ('markdown content to an existing note'), and adds the key constraint 'without replacing it,' which distinguishes it from sibling tools like update_note or create_note. This leaves no ambiguity about what the 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?

The description implies when to use it: add content to an existing note rather than replacing it. However, it does not explicitly name alternative tools or state when not to use it. The phrase 'existing note' hints that create_note is not suitable, and 'without replacing' contrasts with update_note, but this is left to inference rather than stated.

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

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

No annotations are provided, so the description must carry the full burden of behavioral disclosure. It does disclose the key behavioral rule - refusal to overwrite unless overwrite=true - which is critical for safe use. However, it omits other behaviors like permissions, directory creation, or outcome details, leaving some ambiguity.

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

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

The description is concise: exactly two sentences, with the main purpose stated first and the behavioral constraint immediately after. There is no filler or redundancy; 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 create operation, this is nearly sufficient. It explains what gets created, the content type, and the overwrite rule. It does not mention potential side effects (e.g., intervening directory creation) or the return message, but for a 3-parameter tool with no output schema and all parameters documented, the added value is high.

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

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

Schema coverage is 100%, with each parameter having a clear description. The description essentially restates the parameters ('markdown content') and reflects the overwrite default. It adds little beyond what the schema already communicates, so the baseline 3 applies.

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

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

The description clearly states the primary action - 'Create a new note in the vault with markdown content' - and distinguishes it from sibling tools (update_note, append_note) by emphasizing 'new note' and the overwrite guard. An agent can readily separate it from other note-related tools without deeper schema inspection.

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

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

The description does not explicitly guide when to use this tool versus alternatives like update_note or append_note. It implies the create-only purpose via the overwrite refusal, but it never names alternatives or provides conditions for when not to use it. This is left mostly 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. It discloses the critical irreversible nature ('Permanently delete'), but does not mention side effects (e.g., broken links), permission requirements, or recovery options. The 'Permanently' is a meaningful behavioral disclosure, but more would be expected for a destructive 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 with no wasted words. It front-loads the action and scope 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?

Given it's a destructive tool with no annotations and no output schema, the description is sparse. It omits any mention of return behavior, error cases, or confirmations. For a simple one-parameter tool it is minimally adequate, but could benefit from noting that deletion is permanent and perhaps referencing a safer alternative.

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

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

Schema description coverage is 100% for the single 'path' parameter, which is well-documented with an example and instruction to use paths from search/list. The description adds nothing beyond the schema, but that is acceptable given full 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 uses the specific verb 'delete' with the resource 'note from the vault', clearly distinguishing it from sibling tools like create_note, update_note, and get_note. The action and scope 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 implies use when a note is no longer needed, and 'Permanently' signals irreversibility, but there is no explicit guidance on when not to use it or alternatives (e.g., moving to trash). It doesn't mention any precautions or prerequisites.

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

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

With no annotations, the description carries the full burden. It states the action but does not disclose potential side effects, permissions required, or what the command execution returns. This is a significant gap for a tool that can trigger arbitrary Obsidian actions.

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, direct sentence that conveys the core action and the crucial prerequisite. No filler or redundant information.

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

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

For a single-parameter tool with a clear workflow, the description is mostly complete: it names the resource, the identifier, and the prerequisite. The only gap is missing behavioral details like side effects or return values, but given the simplicity, this is a minor omission.

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 already documents the parameter fully (100% coverage), including the example and the 'use list_commands first' tip. The description adds no new meaning beyond the schema.

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

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

The description states a clear verb ('Execute'), a specific resource ('an Obsidian command'), and an identifier ('by its id'). It distinguishes itself from sibling tools by focusing on command execution rather than notes or files.

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

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

The description explicitly instructs to use list_commands first, providing a clear prerequisite and workflow. However, it does not explicitly state when not to use this tool or mention alternatives, though list_commands is the obvious companion.

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 available, the description carries the full burden of disclosing behavior. It only states that it fetches content, which hints at a read-only operation, but does not explicitly mention side effects, permission requirements, return format, or error behavior when no active note exists.

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 conveys the core action and target. Every word adds value, and there is no fluff or redundancy.

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

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

Given the simplicity (no parameters, no output schema), the description is sufficient to understand the tool's purpose. It could mention what happens when no note is active or how to determine this, but for this low complexity level, the current text is reasonably 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 tool has zero parameters and the input schema is empty, so there is nothing to document. The description correctly does not attempt to add parameter information, and the baseline of 4 applies for parameter-free tools.

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

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

The description clearly states the verb 'Get' and the resource 'currently active note', and specifies the content type as 'markdown content', making the purpose specific. However, it does not differentiate itself from sibling tools like get_note, though the 'currently active' qualifier provides useful context.

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 usage is implied: use this when you need the content of the active note. Yet there is no explicit guidance on when to choose this over alternatives such as get_note or search_notes, and no prerequisites 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?

With no annotations provided, the description must carry the full burden of behavioral disclosure. It clearly states this is a read operation that returns markdown content, implying no side effects. However, it does not disclose error behavior (e.g., missing note), whether frontmatter is included, or explicitly confirm the operation is read-only. The basic behavior is clear, but the description adds no detail beyond the verb 'Read'.

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

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

The description is a single sentence that is concise, front-loaded with the action, and contains no filler words or repetition. It effectively states what the tool does without wasted text.

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

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

The description is complete enough for a simple one-parameter read tool. It specifies the return as 'full markdown content', which tells the agent what to expect. The parameter schema covers how to supply the path. While there is no explicit mention of error handling or output format, the lack of an output schema does not make the description incomplete given the clear 'read content' semantics.

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 100% description coverage; the 'path' parameter already includes a detailed explanation (vault-relative, example, instruction to use search/list). The tool description only says 'by its vault-relative path', which adds no new meaning beyond what the schema already provides. Baseline of 3 is appropriate.

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

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

The description clearly states the action (Read), the resource (full markdown content of a note), and the method (by vault-relative path). This distinguishes it from sibling tools like get_active_note, which likely operates on the currently active note without requiring a path, and search_notes, which performs a query.

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 like get_active_note or search_notes. The only hint is in the parameter description, which suggests using a path returned by search/list, but that does not clarify the use case for get_note itself. No exclusions or alternative routing 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 carry the behavioral disclosure burden. It implies a read-only operation ('List') and adds a filter ('that can be executed'), but it does not explicitly state whether it has side effects, the return format, or any access requirements. For a listing tool, the core behavior is mostly clear, but some transparency gaps remain.

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

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

The description is a single, direct sentence that starts with the primary verb and identifies the resource without any filler or redundant phrasing. It is appropriately front-loaded and easy to scan.

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

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

With no parameters and no output schema, the description adequately explains what the tool does. However, it omits details about the returned items (e.g., command IDs, names, or objects) and how they might be used with related tools like 'execute_command'. A brief mention of the output structure would make it more complete.

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

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

The input schema has zero parameters, so the baseline score is 4. There are no parameter details for the description to clarify, and nothing more is needed 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 uses a clear verb 'List' with a specific resource 'all available Obsidian commands that can be executed', making the purpose unambiguous. It distinguishes itself from the sibling 'execute_command' by clearly being about listing rather than executing.

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 'execute_command'. The description does not mention any context, prerequisites, or exclusions, leaving the agent to infer potential use cases from the tool name 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?

No annotations are present, so the description carries the transparency burden. It discloses the root-path convention but does not mention whether listing is direct-only or recursive, whether hidden files are included, or any relevant ordering or error behavior. These are not severe for a simple directory lister, but the description is far from exhaustive.

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

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

The description is a single, direct sentence that states the action, the target, and a key usage tip, with absolutely no fluff or redundant phrasing. Every word contributes.

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

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

For a one-parameter read-only listing tool without an output schema, the description is largely sufficient: it tells the agent what the tool does and how to target the root. The only minor gap is the lack of explicit mention about whether the listing is non-recursive, but this is not a critical omission given typical expectations and the tool's simplicity.

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 already provides a description for the single parameter, so the baseline is 3. The description adds incremental meaning by specifying that both '' and '/' resolve to the vault root, which is not fully captured by the schema's example. This extra semantic guidance earns a 4.

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 specifies a clear verb ('List') and resource ('files and folders under a vault directory'), making its purpose unmistakable. It also clarifies the special root-directory case, and its function is distinct from sibling tools that operate on notes, active notes, or commands.

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 when one needs to browse the vault's file structure, but it does not explicitly contrast it with sibling tools like search_notes or get_note. The root path guidance ('directory=' or '/'') is useful practical direction, but there is no broader when-to-use statement.

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 disclosing side effects and expectations. It only states the core action, without mentioning whether this affects the current UI, requires Obsidian to be running, or has any constraints. The lack of any behavioral detail beyond the primary operation leaves agents uninformed about consequences.

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 opens with the fully informative action. There is no fluff, repetition, or extraneous detail; every word contributes to the stated purpose. It is well-structured for quick parsing by an agent.

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

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

Given the tool's simplicity — one parameter, no output schema, and a straightforward operation — the description provides enough information to call it correctly, relying on the schema for parameter details. However, it does not contextualize the tool among siblings or elaborate on return/effects, though that is less critical for a single-parameter UI open action.

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 covers 100% of the parameter (path) with an example in its description, and the tool description itself adds little beyond restating the need for a vault path. Since the schema already explains the parameter format (e.g., 'folder/Note.md' and the reference to search/list output), the description adds marginal supplemental meaning, so the baseline score of 3 is appropriate.

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

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

The description states a specific verb ('open'), a concrete resource ('a note in the Obsidian app window'), and the distinct mechanism ('by its vault path'). It clearly distinguishes from siblings like get_note or search_notes, as opening in the UI is a different action from retrieving content or listing results.

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 it (when you want a note opened in the Obsidian UI) but does not explicitly state conditions or exclude alternatives. It offers no explicit contrast with other tools, so the usage context is only inferred rather than clearly guided.

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 mentions the return type but does not state whether the operation is read-only, has side effects, or requires any permissions. For a search tool, read-only behavior is implied but not explicitly confirmed.

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

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

The description is two sentences with no fluff. It states the purpose, the syntax, and the return value in a compact, front-loaded manner. Every word adds value.

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

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

For a two-parameter search tool with full schema coverage and a simple return shape described, the description is mostly complete. It lacks details on result ordering, limits, or error handling, but these are not critical for basic invocation. Given the absence of annotations, a slightly richer description could improve completeness.

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

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

The schema description coverage is 100%, so both parameters ('query' and 'context_length') are already documented. The description does not add new semantic meaning beyond the schema, but it reinforces that 'query' uses Obsidian syntax, which is already in the schema. Baseline of 3 is appropriate.

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

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

The description clearly states the tool's purpose: searching notes using Obsidian's search query syntax. It specifies the action ('Search notes'), the resource ('Obsidian vault'), and the return value ('paths, scores, and snippets'), distinguishing it from sibling tools like get_note which retrieve a specific 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 explicit guidance is given on when to use this tool versus alternatives. The description does not mention exclusions or conditions (e.g., 'use get_note when you know the path'). Usage context must be inferred from the tool's name and the search syntax mention.

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 behavioral disclosure. It accurately states that content is replaced, which implies overwriting the original data, but it does not warn about irreversibility or the requirement that the note must already exist. This is adequate but not fully transparent for a destructive operation.

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

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

A single, dense sentence that states the operation, the target, and the content format. No redundant phrases or filler.

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

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

For a simple two-parameter tool with no output schema, the description provides enough to understand the core behavior. It lacks explicit guidance on error cases or irreversible consequences, but given the simplicity and high schema coverage, it is largely 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?

Input schema coverage is 100%, with clear descriptions for both 'path' and 'content'. The description adds no extra parameter-level detail, so it meets the baseline for high schema coverage.

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

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

The description uses a specific verb ('Replace') and resource ('existing note') with a clear scope: the entire content is replaced with new markdown. This distinguishes it from create_note and append_note without needing to inspect the schema.

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

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

The description clearly implies when to use this tool: when the full content of an existing note must be overwritten. It does not explicitly name alternatives, but the phrase 'entire content' and 'existing note' set the context apart from append_note and create_note.

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