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

Annotations already indicate this is a non-read-only, non-idempotent, non-destructive operation, so the description adds little beyond the obvious action of adding an edge. It does not disclose what happens if the canvas or nodes do not exist, whether this modifies the canvas file, or how existing data is affected.

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 and easy to parse, but it is informationally thin. 'Full property support' adds length without meaningful substance, and the critical parameter context is missing.

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 nine parameters, no output schema, and no parameter-level descriptions, this is too sparse. An agent cannot determine edge endpoint semantics, node identifier requirements, or valid property values. It is barely adequate for selecting the tool, not for invoking it correctly.

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

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

Schema description coverage is 0%, so the description must compensate for nine parameters. It offers no explanation of canvas_path, from_node, to_node, from_side/to_side, from_end/to_end, color, or label. 'Full property support' does not convey the meaning or format of any parameter.

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

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

The description uses a specific verb ('Add') and resource ('edge between two canvas nodes'), clearly distinguishing it from sibling tools like add_canvas_node and update_canvas_edge. The phrase 'full property support' hints at feature completeness, though it is vague about which properties are supported.

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 about when to use this tool versus update_canvas_edge or remove_canvas_edges. The name and description imply creating a new edge, but the description does not state when this is the right choice or when an alternative is preferred.

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

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

Annotations already indicate this is a mutation (readOnlyHint=false) and not idempotent. The description adds the behavioral detail of auto-layout when position is omitted, which is beyond what annotations provide. However, it does not disclose other potential side effects, error conditions, or prerequisites, but for a simple add operation this is acceptable given the low bar set by annotations.

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

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

The description is two sentences with no wasted words. The primary action is front-loaded, and the auto-layout detail is placed second, which is useful and efficient. Every sentence contributes 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 tool with 11 parameters, no output schema, and no enum constraints, the description is far too brief. It does not mention required fields (canvas_path, node_type), nor does it explain how to select node types and which fields are relevant for each. An agent would need to infer many parameter semantics from the schema alone, which is risky. The description is not complete enough to safely invoke this tool without additional knowledge.

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 provides some context for x/y (auto-layout when omitted) and hints at node types, but it does not explain the meaning or usage of url, file, text, color, label, width, height, canvas_path, or node_type beyond the list in the first sentence. With 11 parameters and 0% coverage, this is a significant gap.

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

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

The description clearly states the action (Add), the resource (a node to a canvas), and lists the node types (text/file/link/group). It implicitly distinguishes from sibling tools like update_canvas_node and remove_canvas_nodes by using the verb 'Add', and the resource is specific enough that an agent can tell it apart without opening 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 does not explicitly state when to use this tool versus alternatives. It mentions 'Auto-layout when position omitted,' which provides a condition for behavior but not a clear routing guide. The differentiation from update/remove tools is implied by the name and verb, but no explicit 'use this for creation, use update for modification' guidance is given.

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

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

Annotations already declare this is mutating (readOnlyHint false) and non-destructive; the description adds the behavior that the .md extension is appended automatically. It does not describe failure behavior when the note is missing or how newlines are handled, but this is not contradictory to annotations.

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

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

Two short sentences, with the core action first and the extension detail second. No filler 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?

For a two-parameter mutation with no output schema, the description covers the main purpose and the key .md extension behavior. Gaps remain around error handling (missing note) and exact append formatting, so it is minimally viable but not thorough.

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 carry the burden for both params. It implicitly associates path with the note file (including automatic .md extension) and content with the text to append, but offers no details on path format, trailing newlines, or content constraints.

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 clear action ('Append text') and target ('an existing note'), and specifies position ('to the end'), which disambiguates from prepend_to_note and create_note. The mention of automatic .md extension adds useful file-handling detail.

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

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

No explicit when-to-use guidance or named alternatives are given. The wording 'existing note' and 'to the end' implies not for creating new notes or prepending, but an agent must infer this rather than being told.

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

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

Annotations already convey that this is a mutating (readOnlyHint=false) and non-destructive operation; the description's 'Create a new' is consistent with them. It adds little beyond the resource type — no disclosure of what happens if the target path already exists, overwrite behavior, or side effects — but with annotations present, the bar is lower and no contradiction 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?

A single, front-loaded sentence with zero waste; it states the action, resource, and the optional parameters in 13 words. 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-with-optional-content tool this is adequate, but with no output schema and 0% param coverage, key facts are left out: behavior when the file exists, the serialization format of the nodes/edges strings, and what the tool returns. The sibling set (list_canvases, read_canvas, add/update/remove node/edge tools) makes the tool's role clear, but the call contract is under-specified.

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

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

Schema description coverage is 0%, so the description must carry parameter meaning. It clarifies that nodes and edges are optional and represent initial content, which maps to the two nullable params, but it does not specify the expected string format (e.g., JSON-serialized arrays/objects) or what 'path' refers to. This only partially compensates for the coverage gap.

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

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

States a specific verb ('Create') and resource ('.canvas file'), and the qualifier 'new' distinguishes it from sibling tools like add_canvas_node/add_canvas_edge that modify existing canvases. It could be stronger by explicitly naming the sibling it is not, but the resource type alone disambiguates it from create_note/create_daily_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 use for brand-new canvases and that nodes/edges are optional initial content, which roughly signals when to use it versus add_canvas_node/add_canvas_edge. However, it gives no explicit guidance, exclusions, or mention of when to prefer the sibling mutation tools.

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

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

Annotations already indicate this is a mutating, non-idempotent operation. The description adds the important behavioral detail that the tool fails if a daily note already exists, which is not visible in the annotations or schema. It does not disclose side effects beyond creation, but the failure condition is the most decision-relevant 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?

Two short sentences with no filler. The core action, date scope, and failure condition are all front-loaded and each 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?

For a 3-parameter tool with no output schema and no parameter descriptions, the description is minimal but covers the most critical behavior (creation and failure condition). It is missing guidance on parameter semantics and return behavior, but the tool is simple enough that an agent can likely call it correctly with the schema and this description.

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 carries the burden for parameter meaning, but it only explains 'date' implicitly ('for today or a given date'). It does not explain what 'content' or 'template_path' do, nor how they interact (e.g., whether template_path is used when content is null). Baseline 3 is appropriate because the description adds some meaning for date but leaves the other two parameters unexplained.

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

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

The description states a specific verb ('Create') and resource ('daily note'), and adds a scoping detail ('for today or a given date') plus a key constraint ('Fails if one exists'). It is clear enough to distinguish from create_note, though it does not explicitly name the sibling alternative.

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

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

The description implies when to use it: when you want a daily note and one does not already exist. The failure condition ('Fails if one exists') gives a clear exclusion signal, but there is no explicit guidance about when to prefer create_note, get_daily_note, or append_to_note instead.

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

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

Annotations only mark the tool as non-read-only and non-idempotent. The description adds useful behavioral detail: duplicate calls fail, .md is appended automatically, extensions are forbidden in the path, and stubs/backups/temp files must never be created. This goes well beyond the annotations without contradicting them.

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

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

Three short, front-loaded sentences with no wasted words. Each sentence contributes either the core action or a meaningful constraint.

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 covers the core action, duplicate-failure behavior, path conventions, and prohibited file types. It is slightly incomplete because frontmatter semantics are unexplained and success/return behavior is not described, though no output schema exists.

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 clarify parameter meanings. It adds value for path by explaining extension handling, but it says nothing about content semantics or frontmatter formatting, leaving two of three parameters largely underspecified.

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

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

States a specific verb and resource ('Create a new note') plus a unique distinguishing constraint ('Fails if it already exists'). The description also clarifies the extension behavior, making the tool's purpose clear 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 implies create_note is for new notes only, since existing notes cause failure, but it never explicitly points to alternatives like append_to_note or update_frontmatter for modifying existing notes. This is implied usage guidance rather than explicit when/when-not direction.

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?

While annotations already mark the tool as destructive, the description adds important behavioral nuance: the default moves the note to .trash, restore/empty must happen outside the tool ecosystem, and permanent=true triggers an irreversible hard delete. This goes well beyond the annotations and gives an agent the full safety picture needed to call the tool responsibly.

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 compact and front-loaded with the core action, then uses a parenthetical to convey the default behavior and a clear conditional for the permanent flag. Every clause earns its place; there is no filler or repetition.

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 two simple parameters Validity check. The description explains the default vs permanent behavior, the recoverability tradeoff, and the lack of in-tool restore options. No critical invocation details are missing; the description provides enough context for an agent to use the tool correctly and safely.

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 does explain the permanent parameter clearly: default false moves to trash, true is irreversible. The path parameter is not explicitly formatted, but the tool name and 'Delete a note' make its purpose obvious. The description adds meaning beyond the raw schema, though path specifics could be slightly richer.

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 a clear, specific action ('Delete a note.') and immediately distinguishes the behavior from a simple destructive operation by explaining the default trash behavior and permanent hard delete option. This makes it unmistakable what the tool does and how it differs from sibling tools like move_note or create_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 clear context: deleting a note should use this tool, and the permanent flag controls whether the deletion is recoverable. It also explicitly warns that no other tool can restore or empty trashed notes, which helps an agent understand the workflow limits. It does not explicitly compare against a non-existent sibling delete tool, but the guidance is strong.

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

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

Annotations already declare readOnlyHint=true and destructiveHint=false, so the safety profile is covered. The description adds the specific scan scope (wikilinks to nonexistent notes) but does not disclose behavior like folder filtering, result limits, or performance characteristics that would go beyond annotations.

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

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

A single clear sentence that communicates the core function without extra words. It is front-loaded and easy to parse.

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

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

The description is adequate for a default invocation with no arguments, but with no output schema it does not explain the return format, and it does not clarify the semantics of the folder parameter or the max_results limit. Given the tool's simplicity, the gaps are notable but not severe.

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 tool description does not mention either parameter. The agent only has parameter names and defaults (folder=null, max_results=200) to infer meaning from, so the description fails to compensate for the schema gap.

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

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

States a specific verb ('Find') and resource ('wikilinks pointing at notes that don't exist'), which clearly distinguishes it from sibling tools like get_outlinks (links from a note) and find_orphans (notes without backlinks). The intent is unambiguous.

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

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

The description implies the tool is for discovering broken wikilinks, but it does not explicitly say when to use it versus alternatives such as get_outlinks or find_orphans, nor does it mention any exclusions or prerequisites. Usage context is implied 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?

Annotations already declare readOnlyHint=true and destructiveHint=false, which the description does not contradict. The description adds no behavioral detail beyond the core action—no mention of return format, performance, limitations, or side effects. Since annotations cover safety, this is acceptable but not enhanced.

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 concise sentence that states the core purpose without extraneous words. The key action 'Find disconnected notes' is front-loaded, and the three cases are succinctly listed.

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 no output schema and two parameters, the description is too sparse. It does not explain what the tool returns (e.g., note paths), how parameters affect behavior, or how it differs from find_broken_links. An agent might misinterpret 'disconnected' or misuse the parameters.

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

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

Schema coverage is 0% and the description does not explain any parameters. The parameter 'include_outlinks_check' is ambiguous—does it control whether outbound links are considered? 'max_results' is somewhat self-explanatory but no behavior is described. The description fails to compensate for the schema gap.

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

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

Clear and specific: it identifies notes with no inbound links, no outbound links, or both. This distinguishes it from siblings like get_backlinks or find_broken_links by focusing on disconnection rather than broken links or individual link queries.

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 a use case (finding orphans) but does not explicitly state when to use this tool versus alternatives like find_broken_links or get_graph_neighbors. No exclusions or comparative guidance are provided, leaving the agent to infer the appropriate context.

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

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

The annotations already cover the read-only and non-destructive nature of the tool, so the safety profile is clear. The description adds the functional behavior of returning linking notes, but it does not disclose extra behavioral details such as recursive resolution, self-link handling, or empty-result behavior. It does not contradict the annotations.

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

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

The description is a single sentence with no filler, repetition, or unnecessary detail. It front-loads the action and the object, making it immediately scannable for 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?

For a tool with one required parameter and read-only annotations, the description is largely complete: it identifies the input's role and the general output concept. The lack of an output schema and explicit path syntax are minor gaps given the low complexity of the operation.

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

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

Schema description coverage is 0%, so the description must compensate for the bare 'path' string parameter. It does add minimal meaning by indicating that path refers to the given note whose backlinks are sought, but it omits details like path format, relative vs absolute paths, and extension handling.

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 ('find') and a specific resource ('notes that link to a given note'), clearly identifying this as a backlink lookup. It is distinguishable from siblings like get_outlinks, which looks at outgoing links, and find_broken_links, which looks for missing targets.

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

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

The description implies when to use the tool: whenever you need inbound links for a note. However, it never explicitly contrasts this with get_outlinks, search, or find_broken_links, nor does it state when not to use it. This is implied usage rather than clear routing 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?

Annotations already declare readOnlyHint=true and destructiveHint=false, so the read-only nature is covered. The description adds useful behavioral context about the date default ('today's'), but does not describe return content, missing-note behavior, or other runtime details.

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

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

A single, front-loaded sentence with no filler. Every word adds meaning, and the description 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?

Given the low complexity (one optional parameter, read-only annotations), the description covers the essential selection and invocation needs. The lack of an output schema and explicit handling of missing daily notes are minor gaps for such a simple read tool.

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

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

Schema coverage is 0%, so the description must carry parameter meaning. It does so by making clear that the optional 'date' parameter selects either today's note or a specific date's note, which the bare schema does not convey. It stops short of specifying the exact date string format, but for a single optional parameter this is adequate.

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 ('Read') and a concrete resource ('daily note') with date-based scope ('today's or a specific date's'). It clearly distinguishes this from generic note tools like get_note and from create_daily_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 when to use the tool: whenever a user wants a daily note for today or a particular date. However, it does not explicitly name alternatives or state when not to use it, leaving the distinction from get_note and create_daily_note to inference.

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

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

Annotations already declare readOnlyHint=true and destructiveHint=false, so the safety profile is covered. The description adds the depth range (1-5) and default behavior, which is useful. It doesn't disclose traversal direction semantics beyond 'outward' or cycle handling, but for a read-only graph walk the annotations carry much of the burden.

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

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

One sentence, front-loaded with the core action and scope, then the key parameter constraint. 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 read-only graph traversal with 3 params and no output schema, the description covers the core behavior and depth constraint. However, it doesn't clarify what 'direction' accepts (e.g., 'in', 'out', 'both') or what the return shape looks like, which an agent would need for correct invocation.

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

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

Schema description coverage is 0%, so the description must compensate. It explains depth (1-5, default 1) and implies the graph-walk semantics, but it doesn't explain the 'direction' parameter values or what 'path' refers to. The description adds some meaning beyond the bare schema but leaves the direction parameter ambiguous.

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 ('Walk') and resource ('the link graph outward from a note'), which clearly distinguishes it from siblings like get_backlinks and get_outlinks. It doesn't explicitly name a sibling, but the graph-walking framing makes the purpose clear.

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: you use this when you need to traverse the link graph outward from a note, as opposed to get_backlinks (inward) or get_outlinks (direct only). However, it doesn't explicitly state when not to use it or name alternatives, leaving some inference to the agent.

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

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

The description adds behavioral context beyond the readOnlyHint and destructiveHint annotations by mentioning that frontmatter and tags are parsed and that the path extension is optional. This helps an agent understand output structure and input flexibility, though it does not cover error behavior or full return format.

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

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

The description is a single, front-loaded sentence with no filler. Every word adds value, and the most important information (what it reads and returns) comes first.

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

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

For a simple read tool, the description covers the core function but omits details about the returned note structure (beyond frontmatter and tags) and error handling. Since there is no output schema, the description should provide more on return format, making it slightly incomplete.

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

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

The schema provides no description for the 'path' parameter (0% coverage), so the description must compensate. It only notes that the path extension is optional, but does not clarify path format (relative vs absolute) or how it resolves. This is minimal guidance for a critical parameter.

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

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

The description states a specific action ('Read a single note') and what is returned ('parsed frontmatter and tags'), which clearly distinguishes it from list_notes or search. It does not explicitly name alternatives, but the scope is unambiguous.

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

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

No explicit guidance on when to use this tool versus siblings like get_daily_note or search. The usage is implied by the tool's purpose, but no conditions or exclusions are 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?

Annotations already establish read-only and non-destructive behavior; the description adds that the output covers both valid and broken links, giving an agent expectations about the result content. It is consistent with the readOnlyHint and adds value beyond the structured annotations.

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

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

Two short sentences with no filler; the primary action is stated first, and the secondary detail about valid and broken links is appended efficiently. 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 single-parameter tool with annotations, the description is mostly adequate, but because there is no output schema and no parameter details, an agent is left without knowing the expected link output structure or the path syntax. The mention of valid vs broken links gives some context but not enough to fully predict the return format.

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 only refers to 'a note' without explicitly mapping the 'path' parameter to the note's file path, its format, or whether it expects an absolute or relative path. With a single required parameter, more explicit instruction would be needed for correct invocation.

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

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

Description uses a specific verb 'List' with a clear resource 'outgoing wikilinks from a note', and distinguishes itself from siblings by emphasizing 'all' outgoing links and showing both valid and broken links, which differentiates it from get_backlinks (incoming links) and find_broken_links (broken-only links).

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 is for retrieving outgoing wikilinks from a specified note, and its mention of broken links hints at utility for link health checks, but it does not explicitly state when to choose this over alternatives like get_backlinks or find_broken_links, nor does it provide exclusions.

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

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

Annotations already declare this read-only and non-destructive. The description adds the aggregation behavior: unique tags and usage counts. It does not clarify whether tags are extracted from body, frontmatter, or both, or how counts are computed, so it adds only moderate behavioral context beyond the annotations.

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

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

A single, front-loaded sentence with no filler. Every word contributes to the agent's understanding of what the tool returns.

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 tool, the description covers the core return value (tags and counts) and annotations cover safety. However, the only parameter is undocumented and there is no output schema, so the definition is minimally viable but leaves a material ambiguity around sort_by 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?

With schema description coverage at 0% and only a bare 'sort_by' parameter with default 'count', the description needed to document valid sort values or ordering behavior. It does not mention sort_by at all, so an agent must guess whether values like 'name', 'count', or others are supported.

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') with a clear resource ('all unique tags in the vault') and indicates the output includes usage counts. It is immediately distinguishable from siblings like list_notes and search, which address notes/content rather than the tag vocabulary.

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 it should be used when a caller needs all tags with usage counts, but it gives no explicit when-to-use guidance or exclusions, and no mention of how this relates to alternatives like search or note listing. There is no close sibling for tags, so the implication is enough for a minimal score but not more.

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

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

Annotations already declare readOnlyHint=true, so the description doesn't need to repeat that. However, it adds no behavioral context beyond the annotations: it doesn't mention whether listing is recursive, what the folder parameter does, or any limits/pagination. Given annotations cover safety, the description still fails to provide useful behavioral details, so it adds little value.

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

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

The description is a single, concise sentence with no waste, but it is under-specified. While it is appropriately short, it omits essential information about the parameter and behavioral details, so it is not merely concise but incomplete. It balances between being too terse and adequately informative.

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

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

For a tool with one unclear parameter and no output schema, the description is insufficient. It fails to explain the folder parameter, the output format, or any scoping behavior. An agent would struggle to use the tool correctly, especially when a folder is passed, making the definition incomplete.

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

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

The schema has one parameter, 'folder', but schema description coverage is 0% and the description does not mention it at all. An agent cannot infer the parameter's meaning (e.g., filter by folder, scope to subdirectory) from either the schema or description. This is a critical gap that the description should have filled.

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

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

The description clearly states the verb ('List'), the resource ('.canvas files'), and the scope ('in the vault'), making the tool's purpose unambiguous and distinct from siblings like read_canvas or create_canvas. It leaves no doubt 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 purpose is clear enough that an agent would know to use this tool when it needs to enumerate canvas files, but there is no explicit guidance on when not to use it or alternatives (e.g., list_notes for notes). The usage context is implied but not stated, so it meets the baseline but lacks explicit routing.

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

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

The annotations are all false and therefore provide no meaningful behavioral hints. The description does not disclose whether filters combine with AND/OR, how limit applies, whether include_content affects output, or what the response shape is. For a list tool with zero annotation support, the description should carry more behavioral burden.

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

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

A single, front-loaded sentence that conveys the tool's action and primary filter dimensions with no wasted words. Every element contributes to understanding the tool's scope.

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

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

With 9 optional parameters, 0% schema coverage, no output schema, and unhelpful annotations, the description is too thin for an agent to invoke the tool correctly in many cases. Missing details include default limit behavior, the meaning of include_content, and how multiple filters combine.

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 is the only source of parameter meaning. It names most filterable parameters (folder, tags, projects, status, area, frontmatter) but omits limit and include_content, and does not explain how frontmatter_property and frontmatter_value work together. This is partial but not adequate compensation for the schema gap.

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

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

The description uses a specific verb ('List and filter') and a specific resource ('vault notes'), and enumerates clear filter dimensions: folder, tags, projects, status, area, or frontmatter. This makes the tool's purpose unmistakable and distinguishes it from siblings like get_note and search.

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

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

The description implies when to use the tool (whenever you need to list or filter notes) but provides no explicit guidance about when to prefer search or get_note instead. No exclusions or alternatives are named, so the agent must infer usage context.

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

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

Annotations mark destructiveHint true)Skip revisiting. The description adds concrete behavioral details beyond that: wikilinks across the vault are automatically updated, no redirect stubs are created, and .md is appended. This is valuable, though the unrestricted claim that wikilinks are 'always' updated conflicts slightly with the existence of an update_links parameter that can be set to false.

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

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

Three short sentences with all information front-loaded: the primary action first, then the most important side effects and the backup exclusion. Every sentence contributes, and there is no fluff.

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 sparse param schema and no output schema, the description covers purpose, major side effects, and one exclusion, but misses the update_links parameter explanation and possible collisions. For a destructive operation, these are meaningful gaps, so the description is merely adequate, not complete.

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

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

Schema description coverage is 0%, so description must compensate. It implicitly covers old_path/new_path through 'move or rename' and the mention of .md extension, but it says nothing about update_links, its default true value, or how to disable it. Without this, an agent cannot reason about the most configurable part of 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 starts with 'Move or rename a note,' giving a specific verb and resource. It goes further by explaining that wikilinks are updated vault-wide and explicitly distances itself from redirect stubs alerting and from delete_note, making the tool's purpose unmistakable.

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

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

It gives an explicit exclusion, 'Do not use this to create backups; use delete_note instead,' and warns against creating redirect stubs. However, it doesn't cover other potential alternatives or conditions, such as when renaming vs. moving is appropriate or what to do when a destination already exists.

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

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

Annotations already indicate the operation is mutating (readOnlyHint=false) and non-destructive (destructiveHint=false). The description adds valuable behavioral context by specifying the exact insertion point and the automatic `.md` extension. It does not cover edge cases like missing frontmatter or non-existent notes, but the added detail goes beyond what annotations provide.

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 compact sentences with no filler. The core positional behavior is front-loaded, and the second sentence adds a useful operational detail. 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?

The tool is simple and the description covers the main mechanics, but with no output schema and sparse annotations an agent is left guessing about return values and failure behaviors, such as whether the note must already exist. Given the tool's low complexity, this is adequate but not 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%, so the description carries the full burden of explaining `path` and `content`. It implies `content` is the text to insert and `path` gets an `.md` extension, but it never explicitly defines either parameter or explains path formats or whether directories are supported. This is insufficient compensation for the complete lack of schema descriptions.

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

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

The description states a specific verb and resource: inserting text into a note at a precise location (after frontmatter, before the body). This clearly distinguishes it from the sibling `append_to_note`, which would append elsewhere. The automatic `.md` extension detail further clarifies the intended 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?

The description gives no guidance on when to choose this tool over alternatives such as `append_to_note` or `create_note`. There are no explicit conditions, exclusions, or mentions of sibling tools. An agent must infer usage purely from the name and positional wording.

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

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

Annotations already declare readOnlyHint=true and destructiveHint=false, so the safety profile is covered. The description adds that the tool returns nodes and edges, which is useful context beyond the annotations. It doesn't disclose details like whether the canvas must exist or what happens if the path is invalid, but the read-only annotation lowers the bar.

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

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

The description is a single, front-loaded sentence with zero waste. It states the operation and the exact scope (nodes + edges) in six words, which is ideal for an agent scanning tool definitions.

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

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

For a simple read tool with one parameter and read-only annotations, the description is mostly complete. However, it doesn't clarify what 'path' refers to (file path vs. canvas ID) or what the return structure looks like, though no output schema exists. The sibling list includes list_canvases, which could provide context, but the description alone leaves a small 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 must compensate for the undocumented 'path' parameter. The description implies the path identifies the canvas but doesn't specify format, whether it's a file path or ID, or any constraints. With only one parameter, the baseline is 3, and the description adds minimal 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 'Read canvas structure (nodes + edges)' clearly identifies the verb (read), the resource (canvas), and the scope (nodes + edges). It distinguishes this from sibling tools like create_canvas, add_canvas_node, and add_canvas_edge, though it doesn't explicitly name them.

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

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

The description implies usage for reading a canvas's structure, which is distinct from the many mutation tools in the sibling list. However, it doesn't explicitly state when to use this over alternatives like get_graph_neighbors or list_canvases, nor does it mention any exclusions 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?

Annotations already declare destructiveHint=true and readOnlyHint=false, and the description adds no behavioral context beyond stating the action. It does not mention that edges are permanently deleted, whether the operation can be undone, or any permission requirements. With annotations present, the bar is lower, but the description still fails to add any useful behavioral detail.

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

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

The description is a single concise sentence with no wasted words. It is appropriately brief for a simple operation, though it could have been slightly more informative without sacrificing brevity. Front-loading is adequate.

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

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

For a destructive operation with two required parameters and no output schema, the description is incomplete. It does not explain the format of edge_ids (e.g., comma-separated, JSON array) or how the parameters relate. Given the low schema coverage, this is a significant gap that leaves an agent uncertain about how to call the tool correctly.

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

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

Schema description coverage is 0%, so the description must compensate for the lack of parameter explanations. However, it does not clarify that canvas_path identifies the canvas and edge_ids specifies which edges to remove. The phrase 'by ID' is vague and does not map clearly to the parameters. The parameter names are self-explanatory, but the description provides no added 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 states a specific verb ('remove') and resource ('edges from a canvas'), distinguishing it from sibling tools like add_canvas_edge or update_canvas_edge. The phrase 'by ID' is slightly ambiguous—it could refer to the canvas or the edges—but the overall purpose is clear enough.

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

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

No guidance is provided on when to use this tool versus alternatives. There are sibling tools like remove_canvas_nodes and update_canvas_edge, but the description gives no context about when removing edges is appropriate or what distinguishes this from similar operations. Usage must be inferred solely from the name.

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

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

Annotations already flag this as destructive; the description adds the key cascade behavior 'Auto-removes dangling edges,' which is genuine context beyond the structured hints because it discloses that removal affects dependent edges as well. It stops short of richer detail like irreversibility or return behavior, but the annotations lower the bar and this sentence earns its place.

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 zero waste: the core action is front-loaded, and the second sentence adds a distinct behavioral fact. 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 destructive tool with no output schema and 0% parameter coverage, the description leaves too much to inference: parameter formats are unspecified and the return value is entirely unknown. The dangling-edge note is valuable, but an agent still cannot safely and correctly call this on a canvas without further investigation.

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 ID' loosely maps to node_ids but says nothing about format — whether multiple IDs are allowed or how they are separated — and canvas_path is completely unexplained. An agent cannot reliably construct the two required arguments from this text alone.

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 and resource: 'Remove nodes by ID.' The 'nodes' vs 'edges' distinction cleanly separates it from the sibling remove_canvas_edges, and the mechanism ('by ID') adds precision beyond the tool name. An agent can distinguish this from add/update_canvas_node and delete_note without opening schemas.

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

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

The description gives no explicit guidance on when to use this tool versus alternatives, and no exclusions. With 27 siblings including remove_canvas_edges, delete_note, and other canvas mutation tools, an agent gets no routing help. Usage context is only implied by the verb itself.

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

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

Annotations already establish readOnlyHint=true and destructiveHint=false, so the safety profile is covered. The description adds a useful hint about matching modes (text, meaning, exact string), but does not disclose behaviors like hybrid default, result ordering, or the effect of case_sensitive.

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

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

The description is a single front-loaded sentence with no filler. Every word contributes to the core purpose, and it is immediately scannable.

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

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

For a read-only search tool with six parameters and no output schema, the description gives enough for a simple query but omits return-value expectations and advanced filter semantics. It is adequate, not comprehensive.

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

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

Schema description coverage is 0%, so the description must compensate. It adds some meaning around query/mode through 'text, meaning, or exact string', but says nothing about tags, folder, top_k, or case_sensitive, leaving most parameters to be interpreted from their names and defaults alone.

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 names a specific verb and resource ('Find notes') and clarifies the three matching strategies: text, meaning, and exact string. It is clear what the tool does, though it does not explicitly position it against siblings like get_note or list_notes.

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

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

The phrasing implies this is the tool for content-based lookup, but it gives no explicit guidance about when to prefer it over list_notes, get_note, or other retrieval tools. There are no exclusion statements or alternative routing hints.

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

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

Annotations already declare idempotentHint=true and destructiveHint=false, but the description adds no behavioral detail beyond the word 'update'. It does not disclose partial-update semantics (whether unset fields are left unchanged), error handling, or the impact of null parameters, so it fails to add meaningful context beyond structured data.

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 front-loads the action and target. It has no filler, though one might argue it is too sparse for an 8-parameter tool; nevertheless, the brevity itself is clean and structured.

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

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

For a mutation tool with 8 parameters, 0% schema coverage, and no output schema, a one-sentence description is grossly inadequate. The agent is left without knowledge of which properties can be updated, how edge_id and canvas_path are formatted, or what happens when the edge does not exist, making correct invocation unlikely.

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

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

Schema description coverage is 0%, so the description must explain the 8 parameters, but it mentions none of them. Even ambiguous parameters like to_end, from_end, to_side, and from_side are left entirely unexplained, providing zero semantic value to the agent.

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

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

The description states a clear verb+resource: 'Update properties of an existing canvas edge by ID.' It distinguishes from adding or removing edges by saying 'existing' and 'by ID', but it does not explicitly name sibling tools like add_canvas_edge or remove_canvas_edges, so it falls short of a 5.

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

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

No guidance is given on when to use this tool versus alternatives such as add_canvas_edge or update_canvas_node. The description does not mention prerequisites, conditions, or exclusions, leaving the agent to infer usage 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?

Annotations already declare readOnlyHint=false, idempotentHint=true, and destructiveHint=false, so the mutation intent is covered. However, the description adds no behavioral detail about how partial updates work; in particular, it does not clarify whether omitted properties (which default to null in the schema) are preserved or reset to null. This is a critical gap for a tool that says 'any property' can be updated.

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 words. It communicates the core operation efficiently. It loses a point because the brevity borders on under-specification for a tool with 11 parameters and ambiguous null-update semantics.

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

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

Given the tool's complexity (11 params, no output schema, no parameter descriptions), the description is incomplete. It does not address how to update specific fields without affecting others, what the required canvas_path refers to, or what happens when optional properties are omitted. An agent would need to infer critical invocation details from the schema alone.

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% across 11 parameters, so the description must compensate by explaining parameter semantics. It only indicates the node is located by ID and that any property can be updated, without explaining what x, y, url, file, text, color, label, width, height represent, or noting the required canvas_path. This adds minimal meaning beyond the raw schema.

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

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

The description clearly states a specific action ('Update'), resource ('canvas node'), and target scope ('any property', 'by ID'). It distinguishes this tool from siblings like add_canvas_node, remove_canvas_nodes, and update_canvas_edge by framing it as updating an existing node rather than adding or removing one.

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 'existing canvas node' implies use on nodes that already exist, but there is no explicit guidance about when to prefer this over add_canvas_node or remove_canvas_nodes. No alternatives are named, and no conditions or exclusions are provided, leaving the agent to infer routing from the sibling list.

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

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

Annotations already indicate the operation is idempotent and non-destructive. The description adds meaningful behavioral details: merging semantics, preservation of unlisted keys, and automatic extension handling. It does not fully specify overwrite behavior for listed keys, but the added detail is valuable.

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 concise sentences with the core action front-loaded and no filler. Every sentence contributes meaningful operational 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?

The core merge behavior is well covered, but the missing specification of the 'properties' string format is a significant invocation blocker. The simplicity of the tool partially offsets this, but the parameter format gap keeps 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%, so the description must compensate. It indicates that 'properties' holds key-value pairs, but does not explain the required serialization format (JSON, YAML string, line-delimited, etc.). The 'path' parameter is also only clarified by the note about the automatic .md extension.

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 ('merge') and resource ('YAML frontmatter'), and adds behavior ('Unlisted keys preserved', '.md extension is added automatically'). This clearly distinguishes it from sibling content and file operations.

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

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

The description implies this tool is for updating frontmatter keys while preserving others, but it does not explicitly state when to use it versus alternatives or when not to use it. Sibling tools like append_to_note are implicitly different, but no routing guidance is provided.

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

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

Annotations already declare readOnlyHint=true and destructiveHint=false, covering the safety profile. The description adds 'health and statistics' as the expected diagnostic content, but does not disclose additional behavioral details like response shape, cost, or relevance to reindexing. This is acceptable given the annotation coverage, but not exceptional.

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

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

A single, front-loaded sentence with no filler: 'Check search index health and statistics.' Every word earns its place, and the structure is appropriately minimal for a no-input status tool.

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

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

For a zero-parameter, read-only diagnostic tool with annotations covering its safety profile, the description is largely complete. It could specify what statistics are returned or how health is measured, but the low complexity means the agent has enough to invoke the tool correctly.

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

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

The tool has zero parameters, so there is nothing for the description to explain about parameter meaning. Per the baseline for zero-parameter tools, this is a strong score; the description does not need to compensate for any undocumented 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 uses a specific verb ('Check') with a specific resource ('search index health and statistics'), making the tool's purpose immediately clear. It is semantically distinct from sibling tools like search, which queries note content, and vault_reindex, which changes the index, so an agent can tell them apart without opening schemas.

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

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

The description gives no guidance on when to use this tool versus alternatives such as search or vault_reindex. It does not mention whether the agent should first run a health check before searching, or when the statistics would be useful, so the usage context is left 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?

Annotations already indicate this is not read-only, not idempotent, and not destructive; the description adds that the reindex is 'incremental' and scoped. However, it does not disclose execution behavior such as whether the operation is async, what happens to stale entries, or what the return/confirmation looks like.

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 conveys action, scope, and parameter semantics in minimal space, appropriate for a one-parameter tool.

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

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

For a simple tool with one optional parameter and annotations, the description is mostly adequate, but it omits practical details like path format, async behavior, and how to verify the reindex result. Since there is no output schema, some of that burden falls on the description.

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 carries the parameter burden. It clarifies that the single `path` parameter selects one note while null/omission means the entire vault, which is essential. It does not specify the path format (relative path, note name, ID), so it stops short of a 5.

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 ('Trigger') and resource ('incremental reindex'), and clearly delimits scope: one note or the entire vault. This makes it easy to distinguish from sibling tools like vault_index_status or search.

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 scope guidance ('one note or the entire vault') implies when to use it, but there is no explicit condition like 'when the index is stale' and no comparison with alternatives such as vault_index_status. The usage context is present but left mostly implicit.

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