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 delivers: it discloses the upsert behavior (creates if missing) and, more importantly, the significant side effect that it 'auto-commits and pushes to git.' This is exactly the kind of non-obvious behavior an agent needs to know before invoking. It stops short of a 5 by not addressing failure modes or reversibility.

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

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

Three short sentences, zero waste. Each sentence adds a distinct fact: the core action, the edge-case behavior, and the side effect. The most important information is front-loaded 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 2-parameter tool with no output schema and no annotations, the description covers the essential ground: what it does, its create-if-missing behavior, and its git side effects. The only notable gap is return-value behavior, but for an append operation this is a minor omission given the tool's simplicity.

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

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

Schema description coverage is 100%, so the schema already documents both 'path' and 'content.' The description adds only modest context — that content is markdown and that path is relative to the vault — but does not introduce format, encoding, or constraint details beyond the schema. Baseline 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 ('Append') and resource ('note'), and adds a key scoping detail: 'Creates the note if it doesn't exist.' This cleanly distinguishes it from obsidian_write (overwrite), obsidian_read, and the other siblings without needing to open their 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 append-vs-create behavior implies when to use the tool, but the description never explicitly names obsidian_write as the alternative for replacing content, nor states any when-not-to-use conditions. An agent must infer the choice from the verb alone, which is adequate but not explicit.

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

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

With no annotations, the description carries the full disclosure burden. It explicitly reveals a critical side effect—auto-committing and pushing to git—that is not inferable from the tool name. It does not state whether deletion is permanent or moves to trash, but the main behavioral trait is surfaced.

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

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

The description is two short sentences: the primary action is front-loaded, followed by the important side effect. There is no filler or redundant content.

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

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

For a simple one-parameter destructive operation with no output schema and no annotations, the description covers the core action and the critical git side effect. It could clarify trash-vs-permanent deletion, but the overall context is sufficient for an agent to use 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?

The only parameter, path, is already fully described in the schema as 'Relative path to the note to delete' (100% coverage). The description adds no additional parameter meaning beyond what the schema provides, so the baseline score of 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 uses the specific verb 'Delete' with the resource 'note from the vault', making the action unmistakable. It clearly differentiates from sibling tools like obsidian_write, obsidian_append, and obsidian_move even without naming 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?

No explicit when-to-use or alternatives are mentioned, but the verb 'Delete' implies the intended use case. It does not provide exclusions or condition-based routing, so guidance is present only by implication.

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 behavioral burden. It clearly discloses that the tool performs fuzzy matching on titles and returns paths, which is important for an agent to understand the result semantics. It does not explicitly state that it is read-only, but the verb 'search' strongly implies non-destructive 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 concise sentences with no filler. The action and return type are front-loaded, and the usage rationale is a single short phrase. Every sentence contributes useful information.

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

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

Despite no output schema, the description states the return value is note paths, which is the key information an agent needs. The tool is simple with only two parameters and no nested objects, so the description is fairly complete. Minor missing details include path format (e.g., absolute vs vault-relative) and behavior when no matches are found.

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

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

Schema description coverage is 100% for both parameters, with query described as 'Note title or partial name to search for' and limit as 'Max results to return'. The description adds 'fuzzy' and 'best matching' semantics, which slightly infers ranking, but it does not meaningfully expand on the schema's parameter explanations.

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 ('Fuzzy search'), a clear resource ('note by title'), and states the output ('Returns the best matching note paths'). It distinguishes itself from path-based access and full-text search by emphasizing that it works by title and does not require knowing exact paths.

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 'More natural than knowing exact paths' implies when to use this tool, but the description does not provide explicit when-not-to-use guidance or name alternatives such as obsidian_search for content searches. Usage context is implied rather than instructed.

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

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

With no annotations, the description carries the full burden of behavioral disclosure. It does reveal the dual read/update nature of the tool and clearly signals that update mode is a mutation. However, it does not disclose whether updates merge or replace existing frontmatter keys, whether frontmatter is created if absent, or what happens on error, leaving meaningful side-effect uncertainty.

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

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

The description is a single concise sentence with no filler. The core action and resource are front-loaded, and every word earns its place.

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

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

For a simple two-parameter tool, this is adequate but not complete. There is no output schema, yet the description does not state what a read operation returns, nor does it explain update merge/replace behavior or the case where a note has no frontmatter. An agent can call the tool correctly, but would have to assume several edge-case behaviors.

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 adds mild semantic color with examples like tags, status, and date, but it does not clarify how the schema's string-only values map onto potentially structured frontmatter fields such as tags. The schema itself carries the real parameter documentation burden.

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 pair ('Read or update') tied to a concrete resource ('YAML frontmatter of a note'), and even gives example fields. This clearly distinguishes it from generic siblings like obsidian_read and obsidian_write, which operate on full notes rather than frontmatter specifically.

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 makes the intended context clear: working with YAML frontmatter metadata such as tags, status, and date. It does not explicitly name alternatives or say when not to use this tool, but the specialization is strong enough that an agent can infer when to reach for it over the broader note-reading and note-writing siblings.

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

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

No annotations are present, so the description must carry the behavioral disclosure. The word 'Get' clearly signals a non-mutating read operation, and the description states what will be returned: outgoing wikilinks and incoming backlinks. It does not cover missing-note or error behavior, but for a simple query tool the behavioral profile is transparent.

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

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

The description is a single tightly-worded sentence that front-loads the operation and its scope. There is no fluff, repetition, or irrelevant detail.

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

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

For a one-parameter read tool with no output schema, the description adequately conveys the return semantics: outgoing links and incoming backlinks. It is complete enough for an agent to select and call the tool, though exact output format and edge-case behavior are left unspecified.

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%: the only parameter, path, is documented as 'Relative path to the note' in the schema. The tool description adds no extra parameter-level meaning beyond that, 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?

The description uses a specific verb ('Get'), names the resource ([[wikilinks]] in a note), and defines the exact scope: outgoing links and incoming backlinks. This makes it readily distinguishable from sibling tools like obsidian_read or obsidian_tags.

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 use case is implied: call this when you need outgoing or incoming links for a note. However, there is no explicit when-to-use guidance, no named alternatives, and no statement about when other tools like obsidian_read or obsidian_search would be more appropriate.

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

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

No annotations are provided, so the description carries the burden of disclosing behavior. 'List' implies a non-mutating read operation, which is transparent enough at a basic level, but it does not specify what the returned list contains (e.g., paths, titles), whether subdirectories are recursive, or how output is structured.

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

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

The description is one concise, front-loaded sentence with no redundant phrasing. It efficiently communicates both the default behavior and the optional subdirectory behavior.

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

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

The tool is simple, with one optional parameter and no output schema. The description is adequate for basic invocation, but it omits return-format details and recursion behavior, which an agent might need to confidently use the result.

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

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

The input schema provides complete coverage of the single 'dir' parameter, including its default and meaning. The description does not add extra parameter guidance, but with 100% schema coverage this is acceptable and meets the baseline.

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

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

The description clearly states the action ('List') and the resource ('all notes in the vault or a specific subdirectory'). It is specific enough to distinguish from read, search, and write operations, though it does not explicitly name sibling tools.

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

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

The description communicates a clear use case: enumerate notes in the vault or a chosen subdirectory. It does not explicitly discuss when to prefer search, find, or query, but the context is sufficiently clear for a list/inventory operation.

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

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

No annotations are provided, so the description carries the full burden of behavioral disclosure. It does usefully surface the non-obvious side effect 'Auto-commits and pushes to git,' which is important for an agent to anticipate. However, it omits other relevant behavioral details such as whether an existing note at the destination is overwritten, whether backlinks are updated, and what happens on failure or when the git push is not possible.

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 exactly two short sentences with no filler. The primary action is front-loaded first, and the important git side effect is communicated in the second sentence. 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 two-parameter tool, the description plus schema covers the minimum needed to call it: what to move, where to move it, and the git side effect. However, without annotations or an output schema, the description could usefully state whether the destination must not already exist, whether overwriting is allowed, how the move affects vault links, and what return value to expect. These gaps are moderate but not disqualifying for such a simple interface.

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

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

The input schema already describes both parameters ('Current relative path of the note' and 'New relative path for the note') with 100% coverage, so the baseline is 3. The description adds no parameter-specific information beyond confirming that the move happens within the vault, which is already implied by the relative-path wording. It does not clarify path normalization, directory creation, or overwrite behavior.

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

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

The description states a specific verb ('Move or rename') applied to a clear resource ('a note') and scope ('within the vault'), making the tool's function immediately obvious. The action is distinct from sibling tools like obsidian_read, obsidian_write, and obsidian_delete, so an agent can tell this tool apart without inspecting 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 intended use is inferable from the verb 'Move or rename,' and there is no other sibling that clearly performs the same action. However, the description gives no explicit guidance about when to prefer this tool over alternatives, when not to use it, or whether it should be used instead of obsidian_write for path changes. This leaves usage routing mostly implicit.

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

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

No annotations are provided, so the description carries the full burden of disclosing behavior. It says 'pull' but does not explain that this modifies the local workspace, may overwrite local changes, or could fail on conflicts. For a potentially mutating operation with no safety hints, more transparency is needed.

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, front-loaded with the core operation and followed by the key usage trigger. Every word earns its place; there is no redundancy or filler.

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

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

The description covers the basic action and when to use it, which is adequate for a zero-argument tool. However, with no output schema and no annotations, it does not mention outcomes such as local file changes, conflict behavior, or failure modes, leaving some important context to inference.

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

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

The tool has zero parameters, so there are no parameter semantics to document. The baseline for zero-parameter tools is 4, and the description correctly avoids inventing parameter details.

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 and resource: 'Pull the latest changes from git.' This distinguishes it from siblings like obsidian_push (push) and obsidian_read (read local content), 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?

The description gives explicit guidance on when to run the tool: 'when switching devices or after editing notes elsewhere.' It does not explicitly name alternatives or exclusions, but the context is clear enough for an agent to know this is the appropriate action after external 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?

No annotations are present, so the description carries the full burden of behavioral disclosure. It clearly signals a side-effecting operation on git state, which is useful, but it does not mention potential impacts like failed pushes, auth requirements, or whether changes are reversible.

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

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

The description is one short sentence with no wasted words. The action, scope, and target are all front-loaded, making it easy for an agent to parse quickly.

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 optional parameter and no output schema, the description is minimally adequate: an agent knows what the tool does and can invoke it. But it does not explain success/failure behavior or side effects beyond the bare action, and it gives no guidance relative to the sibling pull 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 100% and the only parameter already has a clear description and default value. The tool description adds no parameter-level detail beyond what the schema provides, earning the baseline score of 3.

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 operation ('commit and push'), a clear scope ('all vault changes'), and a destination ('git'), which distinguishes it from sibling tools like obsidian_pull or vault editing tools. It is not tautological or vague.

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 'manually commit and push' implies when to use it: when the user wants to sync vault changes to git. However, it does not explicitly name alternatives or state when not to use it, such as when pulling changes is more appropriate.

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

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

With zero annotations, the description carries the full burden of behavioral disclosure. 'Find' implies a read operation and the matching mechanism is stated, but the description does not disclose whether matching is exact or partial, whether note contents or only metadata are returned, or what happens when no notes match. These behavioral traits are left 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?

One sentence plus an example carries the full message with zero waste. The core action and mechanism are front-loaded ('Find notes by frontmatter field values') and the example immediately clarifies the intended query pattern.

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?

There is no output schema and no annotations, so the description is the sole source of context, yet it never states what the tool returns. It also fails to address how it relates to the overlapping sibling tools. For a low-complexity 2-parameter tool the core invocation is covered, but the missing return-value disclosure and the unaddressed sibling ambiguity leave it incomplete.

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

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

Schema coverage is 100%, so the baseline is 3. The schema already documents both parameters with example values ('status', 'type', 'project') and the case-insensitivity of 'value'. The description's example illustrates how field and value combine, which adds marginal illustrative value, but it does not meaningfully extend what the schema already provides.

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 ('Find'), resource ('notes'), and mechanism ('by frontmatter field values'), with a concrete example ('status = 'in-progress''). This clearly communicates what the tool does. However, with 15 siblings including obsidian_find and obsidian_search, the description does not explicitly differentiate itself, so an agent cannot rule out overlap with similarly named search-like tools.

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

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

No guidance is given on when to use obsidian_query versus alternatives like obsidian_search, obsidian_find, or obsidian_list. The example implies a use case (filtering notes by frontmatter status) but no exclusion or alternative is named. An agent must infer the selection criteria entirely from the tool name and mechanism.

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. The verb 'Read' conveys a non-mutating operation, but the description does not state what happens when the path does not exist, whether the .md extension is required, or what form the returned note content takes.

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

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

A single sentence that front-loads the action and resource, with two compact examples that disambiguate path format. No unnecessary words.

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

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

For a simple one-parameter read tool, the description covers what the tool does and how to specify the path. It does not document error behavior or return format, but these are largely inferable from 'Read a note' and 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 coverage is 100%, so the baseline is 3. The description adds value by showing that 'School/Notes' and 'School/Notes.md' are both acceptable, clarifying that the extension is optional and the path is relative.

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 action ('Read a note') and a precise resource ('from the Obsidian vault by path'), and the by-path mechanism distinguishes it from sibling search/list/find tools that locate notes differently. This is immediately actionable for an agent.

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

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

The description implies the tool is for when the agent already knows the path, and gives path examples. It does not explicitly say when to prefer a sibling tool (e.g. obsidian_search or obsidian_find) when the path is unknown, so usage guidance is only implied.

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

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

No annotations are provided, so the description carries the burden of behavioral disclosure. It adds useful behavior beyond the basic operation by explaining that short notes are returned in full while longer notes show surrounding context. It does not detail output format or limitations, but the key behavioral trait is covered.

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 main action and scope are front-loaded, and the second sentence adds useful behavioral context.

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

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

For a simple two-parameter search tool, the description covers scope and result behavior well, especially with no output schema present. The only gaps are minor details like result limits, ordering, or exact match behavior.

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 both 'query' and 'context_lines', including a default for context_lines. The description only echoes the query concept as a 'text string' and adds no parameter-level detail 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?

States a specific verb ('search'), a resource ('all notes'), and an object ('text string'), making the core action clear. However, it does not explicitly differentiate this tool from siblings like obsidian_find or obsidian_query, which could overlap with a full-text search tool.

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 'Search all notes for a text string' implies this is for vault-wide full-text search, so usage is inferable. But there is no explicit guidance about when to prefer it over sibling tools or when not to use it.

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 full responsibility. It discloses that it scans both frontmatter 'tags:' fields and inline #hashtags, which is key behavioral context for an Obsidian domain where tags can be encoded in multiple ways. It also indicates the relationship (notes that use the tags), though it omits details like sort order or duplicate handling, which are minor for a read-only listing.

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 sentences: the first states the main action and output, the second details the tag sources. No filler, no repetition of schema content, and the most important information 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 simple listing tool with one optional parameter and no output schema, the description covers the essential behavior: what is listed (tags and using notes) and how tags are discovered. It lacks guidance on result formatting or usage edge cases, but these are minor given the low complexity and presence of a schema-documented filter.

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

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

Schema description coverage is 100% for the single optional 'tag' parameter, so the schema already documents the filter. The main description adds no additional parameter semantics beyond what the schema provides; hence baseline 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 (List), resource (all tags in the vault), and the associated notes that use them. Also clarifies scope by naming the two sources (frontmatter 'tags:' and inline #hashtags), which helps distinguish this from broader sibling tools like obsidian_search or obsidian_query.

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

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

The purpose implies when to use it: when you need a tag inventory with linked notes. However, there is no explicit guidance on when not to use it or which sibling alternatives (e.g., obsidian_search for tag-like queries, obsidian_find for locating notes) might be more appropriate. The context is clear but exclusions are absent.

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

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

No annotations are provided, so the description carries the full burden of behavioral disclosure. It confirms this is a creation operation but does not disclose whether existing notes get overwritten, what happens if the template or path is invalid, or how variable substitution behaves. For a mutating tool without annotation coverage, this is a meaningful gap.

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

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

The description is a single, front-loaded sentence with no filler or redundant wording. Every word adds meaning, and the core action and resource are stated immediately.

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

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

The tool has three parameters, variable substitution behavior, a relative path requirement, no annotations, and no output schema, yet the description covers only the core purpose. It does not explain what the tool returns, how vars interact with the template, or what happens on missing/invalid inputs. An agent would need to inspect external documentation or experiment to invoke it reliably.

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 adds modest value by clarifying that the template is a named file in the Templates folder and that the path is relative, but it does not expand on the vars substitution mechanics or path constraints beyond what the schema already states.

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 ('Create a new note') and a specific mechanism/resource ('from a template in the Templates folder'), making the tool's purpose immediately understandable. It is clearly distinguished from generic write/append tools by the template-focused behavior, though it does not explicitly name sibling alternatives.

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

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

The description gives no guidance on when to use this tool versus obsidian_write, obsidian_append, or other siblings. There are no stated conditions, prerequisites, or exclusions, leaving the agent to infer usage solely from the tool name and description. The only usage signal is implicit in the template-based creation 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?

With no annotations, the description carries the full disclosure burden, and it delivers: it reveals the get-or-create (upsert) behavior, the conditional template application, and the Templates folder lookup. It stops short of a 5 because it doesn't state that an existing note is returned unmodified or what the return value is.

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 purpose is front-loaded in the first sentence, and the second sentence provides the conditional template behavior that directly affects what the agent should expect. 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 tool with one optional parameter, full schema coverage, and a clear upsert semantic, the description covers the essentials: operation type, conditional creation behavior, and template source. The only notable gap is the absence of an output schema or description of what the tool returns, but 'get or create' strongly implies the note itself is returned.

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% — the schema already documents the date format (YYYY-MM-DD) and the empty-defaults-to-today behavior. The description adds no parameter-level detail beyond the schema, 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 states a specific verb pair ('Get or create') and a specific resource ('today's daily note'), making the upsert semantic unambiguous. The template detail further distinguishes it from siblings like obsidian_read (pure read), obsidian_write (arbitrary write), and obsidian_template (template management) without needing to inspect any 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 usage context is clearly implied — an agent needing a daily note for a date should pick this tool. However, the description never explicitly states when NOT to use it or names alternatives (e.g., 'for arbitrary file content use obsidian_write'), leaving the routing decision to inference.

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

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

With no annotations provided, the description carries the full burden of behavioral disclosure. It clearly reveals the important side effect of auto-committing and pushing to git, which is non-obvious and critical for an agent to know. It also explicitly states 'overwrite', signaling destructive behavior, though it doesn't elaborate on failure or conflict handling.

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 only two sentences, with the primary action stated first and the important git side effect stated second. Every word earns its place, and there is no redundant or vague filler.

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

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

For a tool with two simple parameters and no output schema, the description adequately explains what the tool does and the key behavioral consequence (git auto-commit and push). It could mention details like whether directories are created or what happens on failure, but these are not essential for correctly invoking the tool.

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

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

The input schema already provides 100% coverage of both parameters: path is a relative path and content is full markdown content. The description adds little parameter-specific meaning beyond indicating the note is written to the vault, so a baseline score of 3 is appropriate.

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

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

The description states a specific verb ('Create or overwrite') and resource ('a note in the vault'), making the tool's core function immediately clear. It also differentiates from siblings like obsidian_read and obsidian_append by explicitly covering both creation and full overwrite semantics.

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 this tool: when a note should be created or completely replaced, rather than appended or modified. However, it does not explicitly name alternatives or state when not to use it, leaving some routing decisions to inference.

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