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

There are no annotations, so the description carries the behavioral burden. It clearly indicates a read-only listing operation, but it does not disclose the output shape, ordering, or whether only direct inbound links are returned. This is adequate for a simple tool but leaves some behavioral details unspecified.

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

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

Two concise, purposeful sentences. The first defines the primary action, and the second adds valuable usage context without wordiness. Every sentence earns its place.

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

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

For a single-parameter read-only tool, the description is largely complete: it states the resource, the behavior, and practical use cases. The lack of an output schema is the main gap, but the phrase 'Lists the notes' gives sufficient expectation of what the call returns for selection and 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 100%, so the schema already documents the single `path` parameter. The description only refers to 'the given note' without adding additional parameter-level detail, 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 opens with a specific verb and resource: 'Lists the notes pointing at the given note.' This clearly defines the backlinks functionality and distinguishes it from siblings like vault_get_note, vault_search, and vault_list, which serve different purposes.

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 use cases: gauging connectedness, finding the MOC that indexes the note, and weighing the impact of changing or renaming it. It does not explicitly mention when not to use it or name alternative tools, but the context is strong enough for an agent to decide when this tool fits.

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, and it does an excellent job: it discloses that the tool commits, removes the MOC line, refuses to delete unsafe candidates, lists who points at the note, breaks links, and returns an undo command. This is exceptional behavioral transparency.

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

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

The description is dense but perfectly structured: the core action comes first, followed by refusal conditions, confirmation behavior, and the undo guarantee. Every sentence adds meaningful information with 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?

For a destructive, mutating tool with no annotations and no output schema, this description covers all the essential context an agent needs: side effects, refusal conditions, confirmation requirements, and even the undo command in the response. It is remarkably 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 100%, so the baseline is 3. The description does not add significant new meaning for 'path' or 'confirm' beyond what the schema already provides; it mostly restates the safety conditions rather than elaborating parameter formats or values.

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 ('Deletes a note and commits'), a resource ('note', 'domain MOC'), and a distinctive side effect (removing its line from the MOC). It also enumerates refusal conditions, so an agent can clearly tell it apart from write, edit, and move siblings.

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 concrete context for when deletion is allowed vs refused: requires a committed version in HEAD, cannot target structural notes or archive paths, and needs confirm when backlinks exist. It does not explicitly name alternatives like vault_move for archiving, so it falls just short of full guidance.

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

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

With no annotations present, the description carries the full burden and does so well. It discloses the commit side effect, the atomic failure mode ('Fails, without writing'), and the exact uniqueness condition that triggers failure. This is valuable behavioral information beyond the schema.

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 conveys the operation, constraints, failure mode, and remediation without wasted words. The most important behavioral constraint, uniqueness and no-partial-write, is front-loaded.

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

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

For a three-parameter edit tool with no output schema and no annotations, this description is complete enough for an agent to invoke it correctly: it knows what the tool edits, when it fails, and how to recover. The schema covers parameter details, and the description covers behavior and error handling.

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 all three parameters with 100% coverage, so the baseline is 3. The description adds extra semantic guidance on old_text: it must be unique and can be expanded with more context if the initial attempt fails. This goes beyond the schema's static 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 uses a specific verb and resource: 'Replaces ONE exact passage of an existing note'. This clearly distinguishes it from sibling tools like vault_write_note (writing a whole note) and read/list tools, even though it does not name them explicitly.

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

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

Usage is implied: use this to replace one exact passage in an existing note. The description does not explicitly contrast it with alternatives or state when not to use it, but it does provide actionable guidance on how to resolve ambiguity by sending more context in old_text.

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

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

No annotations exist, so the description carries the burden. It marks the tool as a read operation and discloses the return payload's key components (frontmatter, resolved links, broken links). It does not mention pagination/truncation with the offset parameter, but the schema already documents that 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 sentences, front-loaded with the action and resource, followed by a workflow note. No filler; the example 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 two-parameter read tool with no output schema, the description gives path format, return contents, and usage context. The offset/cut-marker behavior is captured in the parameter schema, so nothing critical is missing.

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

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

Input schema covers 100% of parameters, so the description need not add much beyond the baseline. The path example ('02-wiki/nestjs/auth-guard.md') provides helpful formatting guidance beyond the schema's 'vault-relative path'.

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 the exact operation ('Reads a whole note') and object (vault-relative path with example), and adds what is included (frontmatter, resolved links, broken links). This clearly separates it from the vault_search snippet behavior.

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?

Explicitly instructs to use it after vault_search when the snippet is insufficient and before editing, naming a concrete alternative and two workflow triggers. This gives an agent decision rules rather than leaving usage to inference.

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

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

With no annotations present, the description carries the full burden of behavioral disclosure and delivers it: server-side routing between append and create, propagation to domain MOC, daily note, and knowledge index for new domains, atomicity ('all in a single commit'), and the returned diff to show the user. This reveals side effects and internal logic that neither the name nor the schema conveys.

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 core action is front-loaded ('Records a learning in the vault') followed by usage triggers, routing behavior, propagation, and return handling. Every clause earns its place and nothing is wasted, though the single run-on sentence with nested dashes and parentheticals is harder to parse than shorter sentences would be.

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 annotations and no output schema, the description covers purpose, when to call, routing decision, multi-target side effects, atomicity, and the diff return — nearly everything an agent needs. The main gaps are not mentioning the new-domain confirmation flow behind confirm_novo_dominio and not describing failure or error behavior, which is minor against the overall complexity.

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

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

Schema description coverage is 100%, so the baseline of 3 applies. The description adds modest extra color by tying the domain parameter to propagation behavior (knowledge index for new domains), but it does not need to compensate for missing schema text and does not explain individual parameter syntax beyond it.

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 — 'Records a learning in the vault' — with concrete examples of what counts (architecture decision, pattern, gotcha, configuration trap). The auto-routing behavior ('the server decides on its own... the bias is to create') clearly distinguishes it from the write/edit siblings, so an agent can tell them apart.

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

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

Gives explicit trigger conditions: 'Call it whenever something non-obvious and reusable comes up' plus concrete scenarios, and instructs the agent not to ask where to save. However, it never names alternatives (e.g., vault_write_note, vault_edit_note) or states when not to use this tool, so the exclusion side is left 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 behavioral burden. It adds useful context by disclosing that the tool filters by metadata and ignores content, but it does not describe return shape, pagination, ordering, or any side effects. 'Lists' implies read-only behavior, but that is not stated explicitly.

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

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

Two sentences with no filler. The core behavior is front-loaded, the metadata filter types are listed, and the exclusion/alternative is given in the second sentence.

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

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

For a filtered-list tool with four optional, well-documented parameters, the description gives enough context for an agent to call it correctly. The absence of an output schema leaves some ambiguity about what fields are returned, but the primary decision of when to use vault_list versus vault_search is fully covered.

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 each parameter already has a clear description in the schema. The tool description reinforces that these are metadata filters but adds no new meaning beyond what the schema provides, so the 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?

States a specific verb ('Lists') and resource ('notes by metadata'), and explicitly clarifies it does not look at content. It distinguishes itself from vault_search by name, so an agent can tell the two tools apart immediately.

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?

Provides explicit when-to-use guidance via inventory examples and directly says 'not to search by subject: for subject use vault_search.' This clearly routes the agent to the correct sibling tool.

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

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

With no annotations provided, the description carries the full burden and does it well: it discloses automatic link fixing, MOC migration, atomic commit behavior, confirmation requirements for new domains, and that a diff is returned. This goes well beyond the bare move/rename semantics and gives an agent a realistic model of the tool's effects.

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 dense but every sentence earns its place: it defines the operation, clarifies path semantics with a concrete example, explains the archive special case, and states the confirmation requirement. The most important behavioral fact (link fixing) is front-loaded.

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

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

For a complex multi-purpose tool with no output schema and no annotations, the description is remarkably complete. It covers the input semantics, the domain-MOC behavior, the archive/unarchive case, the confirmation flow, and the expected user-facing output. An agent has enough to call it correctly in most scenarios.

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

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

Schema coverage is 100%, so the baseline is a 3. The description adds real value by explaining how 'to' encodes the operation kind, that 99-archive can be both source and destination for archive/unarchive, and when confirm_novo_dominio is required. This enriches the schema descriptions without repeating them.

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

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

The description uses a specific verb set ('Moves, renames, promotes or archives a note') and precisely identifies the resource (a vault note) and the core side effect (fixing every link). It distinguishes itself from siblings like vault_edit_note and vault_delete by explaining the unified path-based operation with domain MOC migration.

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 the tool: for any move/rename/promote/archive operation that should stay link-consistent. It gives concrete path examples and explains special cases like 99-archive and confirm_novo_dominio. However, it never explicitly states when NOT to use it or names alternatives like vault_edit_note for content-only edits.

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, and it discloses the key behavioral traits: search quality, exclusion of 01-raw notes unless include_raw, and the path:line citation format. It does not need to discuss side effects because the tool name clearly indicates a read-only search operation.

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

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

The description is compact and front-loaded: purpose first, then usage, then output behavior, then the raw-notes exception. Every sentence conveys a distinct, necessary piece of information with no filler.

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

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

Given the 7-parameter schema, the absence of annotations, and the absence of an output schema, the description covers what the agent needs most: when to use the tool, how results are formatted, and the one non-obvious inclusion/exclusion rule. The remaining parameter details are fully handled by the schema.

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 seven parameters are already documented in the input schema. The description only restates the include_raw behavior, which is already expressed in the schema, so it adds no meaningful semantic value beyond what the agent already has.

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 defines the tool as a vault-wide lexical-semantic search using BM25 plus one wiki-link hop, which is specific and immediately distinguishes it from sibling tools like vault_list and vault_backlinks. It states the verb, resource, and retrieval behavior without ambiguity.

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 explicit instructions on when to call it: before answering questions about the user's decisions, patterns, gotchas, or history, and before recording new learnings. It does not explicitly state when not to use it or name an alternative tool, but the context is clear enough for correct 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?

No annotations exist, so the description carries the full burden — and it delivers. It discloses that the tool replaces the entire file (destructive), commits to the vault's git (side effect), and guarantees a frontmatter block (behavioral guarantee). This is exactly the kind of context an agent needs before calling a write 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?

Two sentences with the core behavior front-loaded and the caveat plus alternatives in the second. Minor redundancy exists between 'Creates or replaces a whole note' and 'It replaces the entire file,' but the former sets scope while the latter emphasizes destructiveness, so each clause 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 write tool with no output schema and no annotations, it covers the essentials: operation, destructive scope, git-commit side effect, frontmatter handling, and sibling routing. The one gap is that it never describes the return value or confirmation behavior on success, which would be valuable given there is no output schema. Otherwise an agent has everything needed to call 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 100%, so path, content, and frontmatter are already fully documented. The description adds marginal value with 'frontmatter guaranteed' (clarifying the caller avoids the frontmatter block in content), but provides no extra format or syntax details. Baseline 3 is appropriate since the schema does the heavy lifting.

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 ('Creates or replaces'), a clear resource (a whole note), and unique scope: it replaces the entire file while guaranteeing a frontmatter block. It also names sibling tools vault_edit_note and vault_learn as the tools for different jobs, so an agent can distinguish it 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?

Explicitly routes away from this tool: 'to change one passage use vault_edit_note' and 'to record a learning use vault_learn' with the reasoning that vault_learn picks the destination and propagates on its own. The whole-file vs one-passage distinction gives a clear decision rule for when to use vault_write_note instead.

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