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

No annotations are provided, so the description carries the full behavioral burden. Beyond the destructive verb it says nothing about irreversibility, required permissions, cascade effects on related items, or behavior when the UUID is unknown.

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 short sentence, front-loaded with the action and resource, containing no filler. Size is proportionate to a single-parameter tool.

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

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

For a destructive, unannotated mutation with no output schema, the description is too thin: it omits reversibility, error handling for missing UUIDs, and permission requirements that an agent needs before invoking it.

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 single parameter is fully documented in the schema, so the schema does the heavy lifting. The phrase 'by its UUID' only echoes the schema's format hint without adding new meaning.

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

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

Specific verb 'Delete' plus resource 'knowledge item' with a clear identifier qualifier ('by its UUID'). It is distinguishable from the sibling search_/list_/record_ tools, though it never explicitly contrasts itself with record_knowledge or names a boundary condition.

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 statement of when to use this tool versus record_knowledge, list_knowledge, or the search variants, and no preconditions or consequences of use. The agent must infer that deletion follows a lookup step.

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 does disclose two real behavioral traits: results are ordered by most recently updated, and the key is not shared across worktrees. It still omits return shape, result limits/pagination, and any permission or auth expectations for a read over a knowledge store.

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, zero padding, with the core purpose front-loaded and the scoping caveat second. The worktree sentence is terse enough to border on cryptic, but it earns its place as a distinct warning.

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 covers purpose, ordering, and key scoping, which is close to adequate. It stops short of saying whether the listing can be large or truncated, which is the one piece of context an agent would need to call it safely.

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

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

Schema coverage is 100%, so the sole parameter is already fully documented. The description restates the exact-key constraint and 'no worktree/family resolution' but adds no format examples or guidance beyond what the schema text already says, 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?

States a specific verb (List) and resource (knowledge) with an explicit scope qualifier (exact repository-path key) and an ordering guarantee. It does not name the nearest sibling search_knowledge, so an agent must infer the list-vs-search distinction rather than being told directly.

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 rather than stated: the exact-key scoping and recency ordering suggest this is the tool for enumerating everything under one repo rather than querying. There is no explicit 'use this instead of search_knowledge when...' routing and no stated prerequisites or exclusions.

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

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

With no annotations, the description carries the full burden and does disclose two real behaviors: items are embedded/indexed and become searchable via search_knowledge, and repo keys are not worktree-resolved. It does not say whether an 'id' update replaces or merges unspecified fields (body vs tags), nor anything about auth or side effects of re-embedding, leaving meaningful behavior undisclosed.

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 tight sentences: scope and keying constraint first, retrieval linkage second, update-vs-insert rule last. No filler and nothing redundant is front-loaded ahead of the essential constraint.

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

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

For a six-parameter write tool with no output schema and no annotations, the description covers the discriminating semantics (key handling, upsert, embedding/searchability). It lacks only the response shape (e.g., whether a new id is returned) and partial-vs-full update behavior, which are minor given the 100% schema coverage.

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 every parameter is already documented, including the id insert/update switch and the repo worktree caveat. The description restates those semantics rather than adding new meaning (no format, length, or tag-normalization guidance), so the 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 and resource ('Store a curated knowledge item') plus the keying rule ('exact repository-path key, no worktree/family resolution'). It also clarifies the upsert nature and names the sibling that reads the data back (search_knowledge), so an agent can distinguish it from search_*/list_*/delete_* without opening a 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?

Explicitly says to provide 'id' to update versus omit to insert, and points to search_knowledge for retrieval, giving clear context for use. It stops short of stating when-not-to-use (e.g., preferring list_knowledge or delete_knowledge paths), but the routing is unambiguous for a write tool surrounded by read tools.

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

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

With no annotations, the description carries the full burden and does meaningful work: it discloses that a first search can register and index a new linked worktree, that subsequent searches reuse the last completed index, and that incomplete Git operations retain it. These are non-obvious side effects for a tool named 'search'. It stops short of permissions, limits, or result-shape 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?

The matching semantics and the repo/cwd precedence rule are front-loaded, and every sentence carries information. The later sentences on worktree registration and index reuse are dense and slightly elliptical, but they are not padding.

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 must cover a fair amount, and it covers path resolution and indexing behavior well. It leaves gaps on query syntax, the meaning of limit, and what results look like, which matters for a search tool whose whole value is the result set.

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 50%: cwd and repo are documented in the schema, while limit and query are not. The description does add real meaning beyond the schema by explaining the repo-vs-cwd precedence and how each resolves (Git worktrees vs directory roots). It does not clarify query tokenization rules or limit behavior, so it only partially compensates for the coverage gap.

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

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

The description names a specific verb and resource ('Tokenized full-text keyword search') and immediately delimits the matching model against alternatives ('not literal substring or regex matching'). It is easy to distinguish from search_structural, but it never names search_hybrid or search_semantic, so the sibling differentiation is implied rather than explicit.

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 guidance on how to point the tool at a target ('Supply repo ... or cwd ...; repo takes precedence'), which is genuine usage context. However, it never states when to choose this tool over search_hybrid/search_semantic/search_structural, leaving the primary 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, the description carries the full burden and does disclose real side effects: a first search can register and index a new linked worktree when its family permits, and subsequent searches reuse the last completed index. It also notes incomplete Git operations retain the prior index. It omits auth requirements, rate limits, and result format, so it is strong but not complete.

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?

Front-loaded with the purpose, then parameter resolution, then indexing behavior — a sensible order with no filler sentences. It is dense with domain jargon (families, registered roots, linked worktrees) that could be tightened, but every sentence carries 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 4-param search tool with no output schema and no annotations, the description covers targeting and indexing but says nothing about result shape, ranking, or the meaning of 'limit'. An agent knows how to aim the tool but not what comes back.

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 50%: 'cwd' and 'repo' are documented in the schema, while 'limit' and 'query' are bare. The description adds genuine value on the two covered params — absolute path meaning, precedence of 'repo', and worktree-vs-directory-root resolution — but does nothing for the undocumented 'limit', so it only partially compensates.

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 ('Semantic + fulltext hybrid search over indexed repos') and the word 'hybrid' immediately distinguishes it from the sibling search_fulltext and search_semantic tools. An agent can tell what it does without opening the schema.

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

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

It explains how to target a repo (repo vs cwd precedence) but never states when to choose this tool over search_fulltext, search_semantic, or search_structural. The hybrid nature implies 'use when you want both signals,' but the routing decision 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?

With no annotations, the description carries the full burden. It does disclose a real behavioral trait — no worktree/family resolution, so the key must match exactly — but omits ranking behavior, result limits/pagination, and any permission or rate-limit context.

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 dense sentences with the search-mode-and-scope constraint front-loaded; every clause carries information. Minor redundancy in restating the no-worktree-resolution rule that also appears in the repo schema description.

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?

Complete for a hybrid search over a knowledge base: the key behavioral constraint (exact repo key, no resolution) and the recommended key choice are stated. Return format and ranking needn't be explained since there is no output schema, though limit/pagination semantics remain unaddressed.

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 only 33% (only 'repo' documented), so the description must compensate. It adds meaningful semantics for 'repo' (exact key, no worktree/family resolution, main-checkout for shared notes), but says nothing about 'query' syntax or the 'limit' parameter's meaning or default.

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: 'Hybrid semantic + fulltext search over curated notes'. The scope ('curated notes under an exact repository-path key') distinguishes it from the generic search_hybrid/search_fulltext/search_semantic siblings by data domain, though it never names an alternative outright.

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 by the 'curated notes' domain and the directive 'Use the established main-checkout key for shared notes', which tells the agent which key to supply. However, it gives no explicit when-to-use-this-vs-search_hybrid guidance or exclusions, leaving the sibling choice 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, the description carries the full burden and does disclose real side effects: a first search may register and index a new linked worktree, subsequent runs reuse that checkout's last completed index, and incomplete Git operations retain it. It does not state read-only-ness or return format, but the registration/indexing disclosure is unusually rich.

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?

Front-loaded and not bloated, but several sentences ('Git worktrees resolve through Git and registered families') are jargon-dense and hard to parse. The behaviorally important indexing caveat is buried mid-paragraph.

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 no-annotation, no-output-schema search tool it covers indexing/registration lifecycle well, but omits what is returned, how ranking works, and the semantics of 'limit'. An agent can invoke it, but not fully predict its output or cost.

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 50%. The repo/cwd descriptions already cover much of what the prose repeats, but the description adds genuine value with the precedence rule ('repo' takes precedence). 'limit' and 'query' remain undocumented in both schema and description.

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 opening 'Vector similarity search' gives a specific mechanism+verb that implicitly distinguishes this from search_fulltext, search_hybrid, and search_structural. It never names those siblings, though, so the agent must infer the routing rather than being told it.

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 the repo-vs-cwd selection well, including precedence, but gives no guidance on WHEN to pick semantic search over the sibling search_* tools. Usage relative to alternatives is left entirely to inference.

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

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

With no annotations, the description carries the full burden and does disclose real behavior: caller-file preference with tie-keeping, checkout-wide fallback, first-search registration/indexing of linked worktrees, reuse of the last completed index, and retention under incomplete Git operations. It omits return shape, result limits, and error behavior, which keeps it below 5.

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?

Purpose is front-loaded and every sentence carries substantive information about resolution and indexing. The prose is dense and jargon-heavy with several long compound sentences, so readability suffers slightly, but there is little outright padding.

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?

No output schema and no annotations mean the description must cover purpose, path handling, and indexing lifecycle, which it largely does. It leaves unspecified what a returned candidate looks like, ordering guarantees for results, and how to read the 'verify paths and source' warning operationally.

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 50%: cwd and repo are documented in the schema, symbol and relation are not. The description adds genuine meaning for the path pair ('repo' absolute, takes precedence; 'cwd' a directory inside it), but contributes nothing about the required 'symbol' or 'relation' parameters beyond the enum being self-describing.

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+resource: finding name-based related-symbol candidates via a relation (callers/callees/imports/etc.), and explicitly disclaims compiler-verified bindings. It is meaningfully distinguished from the name search siblings (hybrid/fulltext/semantic) even without naming them. It stops short of naming an alternative, so it is not a 5.

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

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

Usage is implied by the resolution rules (Git checkouts vs directory roots) and the 'Verify paths and source' caution, but there is no explicit when-to-use-this-vs-search_hybrid/semantic/fulltext guidance. The agent must infer that this tool is for relation traversal rather than fuzzy/text search, and no exclusions are stated.

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