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

Annotations already declare readOnlyHint=true and openWorldHint=true, so the safety profile is covered. The description adds the behavioral context that it returns the note currently open in the editor, which is useful. It does not, however, disclose edge cases like behavior when no note is active or what happens if content is not included. Given the annotations cover the main safety aspects, a 3 is appropriate.

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, information-dense sentence followed by a precise usage hint. Every word earns its place, and the core purpose is front-loaded. There is zero redundancy, making it an excellent example of conciseness.

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 no output schema, the description sufficiently covers what the tool does and when to use it. It doesn't mention error handling or what happens when no note is active, but the simplicity and existing annotations make this a minor gap. The description is complete enough for an agent to correctly invoke this tool 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?

The schema description coverage is 100% for the single parameter includeContent, with a clear description ('Include the note body, or only its path.'). The tool description does not add any parameter-specific guidance, but that's acceptable because the schema already fully documents the parameter. Baseline of 3 is appropriate when the schema handles parameter semantics.

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

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

The description clearly states the tool's purpose: to retrieve the currently open note in Obsidian. It uses a specific verb ('get') and resource ('active note'), and distinguishes itself from siblings like read_note by focusing on the note the user is currently viewing. The phrase 'what the user is looking at right now' adds concrete context, and the usage example ('this note') reinforces the intent.

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

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

The description provides an explicit trigger for when to use this tool: when the user says 'this note' without naming it. This gives clear guidance on when to select it over alternatives like read_note. However, it doesn't explicitly state when not to use it or name alternatives, though the sibling list makes the distinction implicit. This is a strong usage guideline but not fully exhaustive.

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 openWorldHint=true, so the safety profile is covered. The description adds behavioral detail: results come from Obsidian's link index and match the backlinks pane exactly, including alias-written links. This clarifies data source and matching semantics beyond the annotations, so it adds 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?

Two short sentences, front-loaded with the core action. The first sentence states exactly what it does; the second adds a helpful detail about matching the backlinks pane and aliases. Zero waste and no repetition of schema or annotations.

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, single-parameter tool with open-world semantics, the description is sufficient. It explains the tool's output scope (incoming links), source (link index), and matching behavior (including aliases). Annotations cover safety, and the schema covers the parameter, so nothing essential is missing.

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

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

The single parameter 'path' is fully documented in the input schema (100% coverage), so the description doesn't need to explain it. The description adds no extra param-specific meaning, but that's fine because the schema is complete. 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?

The description clearly states the tool's function: returning notes that link to the given note. It uses a specific verb and resource, and implicitly distinguishes from sibling get_links (which likely handles outgoing links) by focusing on incoming links. The phrase 'Notes that link *to* this note' 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?

It explains that the result matches Obsidian's backlinks pane exactly and includes aliases, giving context on when to trust its output. It does not explicitly contrast with get_links or state 'use when you need incoming links', but the purpose is clear enough that an agent can infer usage. A minor gap: no explicit 'when not to use' guidance.

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

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

The description adds meaningful context beyond the readOnlyHint and openWorldHint annotations. It explains that Obsidian resolves link targets, clarifying the returned paths, and defines 'unresolved' as links to non-existent notes. This helps the agent understand the tool's behavior and output semantics without contradicting 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 two sentences and front-loaded with the core purpose. It includes the unresolved caveat and a potential use case without unnecessary fluff. It is concise and structured effectively, though it could be slightly improved by separating the use case into a clearer line.

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 two parameters and no output schema, the description covers the essential behavior: what links are returned, how targets are resolved, and the special unresolved case. The includeDetails parameter is described in the schema, so the description focuses on semantics. It is complete enough for an agent to call the tool correctly, with only minor gaps like explicit return format examples.

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

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

Schema coverage is 100%, with both parameters (path and includeDetails) fully described in the schema. The description does not add extra parameter-specific semantics; it only mentions a behavior related to unresolved links. Per the rubric, the baseline is 3 when schema coverage is high, and the description does not go beyond that.

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 and resource: 'Notes this note links to.' It explicitly distinguishes outgoing links from incoming ones via the tool name and mentions the special 'unresolved' case, which adds clarity beyond the title. An agent can immediately understand what the tool returns and how it differs from siblings like get_backlinks.

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 a specific use case ('useful for finding gaps to fill') but does not explicitly mention alternatives or when not to use it. It implies usage for exploring outgoing links but lacks direct comparison to siblings like get_backlinks, search, or read_note. The guidance 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?

Annotations already declare readOnlyHint and openWorldHint, so the safety profile is covered. The description adds meaningful behavioral context: the call excludes the note body and is cheaper than read_note, which goes 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?

Two concise sentences front-load the primary function and then add the cost/use-case distinction. Every sentence earns its place 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 one simple parameter, read-only annotations, and no output schema, the description adequately summarizes what is returned (tags, frontmatter, stats) and what is not (body). The only minor gap is the vagueness of 'file stats', but this does not impede 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 100%, and the path parameter is already well documented with an example and extension-optional note. The description adds no additional parameter semantics, so the baseline 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 a specific verb and resource ('Get a note's tags, frontmatter, and file stats') and explicitly contrasts itself with read_note, making its scope clear. An agent can immediately tell this from the 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?

It names the alternative read_note and gives the selection condition: use this when you only need how a note is classified. This directly tells the agent when to prefer this tool over a body-reading alternative.

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

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

Annotations already declare readOnlyHint=true and openWorldHint=true, covering safety. The description adds valuable behavioral context: it lists only direct contents (non-recursive) and reports subfolders separately from files. This goes beyond the annotations and helps the agent predict the output structure without overstating anything.

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 that front-load the core action and immediately address the root edge case and output structure. There is no filler or redundancy; 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 simple one-parameter read-only tool, the description covers the essential behavior: direct listing, root handling, and subfolder separation. It does not describe error behavior or the exact return format, but with no output schema and a straightforward operation, these omissions are minor and unlikely to impede 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?

The schema already describes the path parameter as 'Vault-relative folder path. Empty for the vault root' with 100% coverage. The description adds the alternative of passing '/' for the root, a minor clarification that does not fundamentally alter the parameter meaning. Since the schema carries the bulk of the semantics, a 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?

The description states a specific verb ('List') and resource ('files and subfolders directly inside a folder'), clearly distinguishing it from sibling tools that operate on notes or search. It also specifies the root behavior and the separation of subfolders, leaving no ambiguity about the tool's function.

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 clear context for when to use this tool (to list folder contents) and provides practical guidance on the path parameter ('Omit the path or pass '/' for the vault root'). It does not explicitly name alternatives or exclusions, but the sibling set is distinct enough that usage intent is unambiguous.

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 cover readOnlyHint and openWorldHint, so the safety profile is known. The description adds valuable behavioral scoping: the tool returns full markdown content only, not frontmatter or links, preventing incorrect expectations. It doesn't detail missing-path behavior, but the readOnly context and simple scope make this a minor 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?

Two sentences with the purpose front-loaded and sibling routing in the second sentence. Every clause earns its place; there is 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?

For a one-parameter, read-only tool, the description plus schema fully covers what the tool accepts, what it returns, and how it differs from siblings. No output schema exists, but return value is clearly implied by 'full markdown content,' and error behavior is not critical given the readOnlyHint.

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%, and the schema fully documents 'path' including Vault-relative format, example, and optional extension. The description adds no parameter-level detail beyond the schema, so 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+resource ('Read a note's full markdown content') and distinguishes from siblings by directing get_metadata to tags/frontmatter and get_links/get_backlinks to connections. An agent can tell exactly what this tool provides versus adjacent 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?

Explicitly routes the agent to alternatives: 'Use get_metadata for tags and frontmatter, and get_links/get_backlinks about connections to other notes.' This is clear when-not guidance that leaves nothing 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 and openWorldHint, and the description adds useful behavioral detail beyond them: results are 'matching notes with snippets and scores, best match first.' It also reveals the use of 'Obsidian's own search,' which hints at supported search syntax. It doesn't discuss auth or rate limits, but for a read-only search these are not critical.

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 core action. Every clause adds value: scope ('across the vault'), engine ('Obsidian's own search'), returned data ('matching notes with snippets and scores'), and ordering ('best match first'). There is 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?

With no output schema, the description is the only source for understanding the return value. It says 'matching notes with snippets and scores' but does not state what a 'note' object contains (e.g., path, title, or ID) or how to reference results for subsequent actions like read_note. This is a real gap for an agent trying to chain tools, so a higher score is not warranted.

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 meaning by clarifying that the query is a full-text search over the vault, rather than just 'Search text.' It also contextualizes the ordering of results relative to relevance ('best match first'). The limit parameter remains schema-defined, but the added query semantics justify a 4.

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

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

The description states a specific verb and resource: 'Full-text search across the vault.' This clearly differentiates the tool from siblings like read_note (reading a single note), list_folder (listing folders), and get_metadata (viewing metadata). The added return details (snippets, scores, best match first) further pin down its unique role.

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 'Full-text search across the vault' establishes a clear use case: finding notes by content across the entire vault. However, it does not explicitly mention when not to use it or name alternatives (e.g., use read_note when you already know a note path), so it stops short of a 5.

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 meaningful behavioral context beyond the annotations: overwriting replaces the entire file (destructive warning), the 'read first' recommendation, and refusal when server is read-only. These are not present in the annotations, so the description adds 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?

Two sentences, no fluff, warnings front-loaded after the core action. Every sentence carries 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?

For a 3-parameter write tool with no output schema, the description covers the key behavior, the destructive caveat, and a server-state constraint. It is sufficient for an agent to invoke safely, though it could mention the response type or idempotency explicitly, which are absent.

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 has 100% coverage and already explains mode, path, and content. The description does not add new parameter-level meaning beyond what the schema states. 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 states a specific verb and resource: 'Create or overwrite a note, or append to it.' It clearly distinguishes this from the read/search/list siblings by focusing on write operations. The purpose is unambiguous and immediately identifiable.

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 practical guidance: 'read the note first unless you mean to replace it,' which implicitly directs the agent to use read_note or similar before overwriting. It also notes the read-only server limitation. It does not explicitly name sibling alternatives but the context is clear enough.

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