lilbee

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 real behavior: the add is followed by a sync, paths are absolute and resolve on the lilbee host rather than the caller (critical for remote servers), and URLs are single-page fetches. It does not cover duplicate handling, idempotency, or what happens on partial failure, which matters for a mutating tool.

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

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

Three tight sentences, front-loaded with the action, then the path-resolution caveat, then the sibling pointer. Every sentence earns its place and nothing is repeated from the schema.

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?

An output schema exists, so return values need not be explained. For a mutation tool with five parameters and no annotations, however, the description leaves gaps around duplicate/overwrite behavior and two undocumented parameters, making it adequate but not fully self-sufficient.

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 only 40%, so the description must compensate, and it only explains `paths` (absolute, server-side resolution) plus URL behavior. `force` and `ocr_timeout` are undocumented in both places, and `ocr`/`render_mode` get no elaboration beyond their enum descriptions.

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

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

States a specific verb and resource set (files, directories, URLs into the knowledge base) and pairs it with the implicit follow-up action (sync). It also explicitly distinguishes itself from the sibling `crawl`, so an agent can route between the two without inspecting either 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?

Gives clear routing guidance: URLs are fetched as single pages, and `crawl` is named for whole sites. That covers the main ambiguity for this tool. It stops short of explicit exclusions against other ingestion siblings such as `import_dataset` or `init`, so it is clear context rather than complete when/when-not guidance.

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

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

With no annotations, the description carries the full burden of behavioral disclosure. It explains the meaning of enum-like values (e.g., max_fit: fits/tight/wont_run) but does not disclose pagination behavior, default sort, whether 'featured' and 'installed' are filters or flags, or what the response contains. The output schema exists but the description itself adds little behavioral context beyond value semantics.

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

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

The description is compact and front-loads the main purpose in the first sentence, then uses a terse key: value format for parameter semantics. It is efficient, though the formatting is slightly telegraphic and could be clearer with a short sentence about how filters combine.

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 9-parameter browse tool with no annotations and 0% schema coverage, the description covers the core filter dimensions but leaves limit, offset, search, featured, and installed unexplained. The output schema exists, so return values are partially covered, but an agent would still be guessing about pagination and filter semantics. This is a minimally viable description with clear gaps.

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

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

Schema description coverage is 0%, so the description must compensate. It does add meaning for four parameters (task, size, max_fit, sort) by listing allowed values, which is genuinely useful. However, five parameters (limit, offset, search, featured, installed) are left entirely undocumented, and the description does not explain how the parameters combine, so the compensation is only partial.

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 ('Browse the model catalog') and enumerates the key filter dimensions (task, size, max_fit, sort), which distinguishes it from sibling tools like model_list and model_show. However, it does not explicitly contrast itself with those siblings, so it loses a point for not naming the alternative.

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

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

The description implies usage by listing the filter dimensions and their allowed values, giving an agent a sense of how to narrow a catalog browse. It does not state when to prefer this over model_list or model_show, nor does it mention any exclusions or prerequisites, so the guidance is only 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 must fully disclose behavior. It only states the basic action without mentioning side effects, reversibility, or error conditions.

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, minimal sentence that conveys the core purpose without 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 tool with no parameters and an output schema, the description is mostly complete but lacks context on prerequisites or result details.

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?

No parameters exist, so baseline score of 4 applies; no additional parameter description needed.

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 (clear) and the resource (manual placement), and distinguishes it from siblings like preview_placement.

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 on when to use this tool versus alternatives like add or remove, nor any prerequisites or contexts.

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 the key behavioral trait: the crawl is non-blocking and results must be polled via crawl_status. However, it omits other important behaviors such as default max_pages, whether include_subdomains affects scope, rate limiting, or any permission requirements.

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?

Dense but front-loaded: the non-blocking nature and polling path come first, followed by parameter shorthand. Every clause carries information, though the backtick-heavy telegraphic style trades some readability for compactness.

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?

Since an output schema exists, return-value detail is unnecessary, and the async polling model is covered. The gap is on the input side: two of five parameters have no semantics anywhere, and there is no indication of crawl scope limits or failure 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 coverage is only 20%, so the description must compensate. It usefully explains depth values including the null = whole-site case, which contradicts the schema's integer type and would otherwise be undiscoverable. But max_pages and include_subdomains remain undocumented in both the schema and the description, and the render_mode explanation merely repeats the schema text.

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 ('Start a non-blocking crawl') and the non-blocking qualifier immediately sets it apart from the synchronous siblings. It also names the follow-up tool crawl_status(task_id), making the crawl lifecycle obvious. It never says what a crawl actually does (presumably fetch linked pages from a site), leaving the resource slightly opaque.

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 a follow-up protocol ('poll via crawl_status(task_id)') rather than when-to-use guidance, and it encodes depth semantics (0 = single URL, N = N levels) that help choose parameters. There is no explicit statement of when to prefer this over siblings like search or catalog_browse, and no exclusions or prerequisites.

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

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

No annotations are provided, so the description carries the burden. It reveals that pages already saved are kept, which is useful. But it does not mention other behaviors like whether the cancel is immediate, error handling, or permission requirements, leaving some gaps.

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, front-loaded sentences with zero waste. Every word earns its place, clearly stating the action and a key behavioral consequence.

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 cancel operation, the description covers the main purpose and the key side effect (saved pages kept). An output schema exists, so return values need not be explained. Minor missing details about edge cases (e.g., task not found or already finished) are acceptable 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?

The schema has one required parameter, task_id, with no description. The tool description does not explain what task_id is or where to obtain it (e.g., from a crawl call). With 0% schema description coverage, the description should compensate, but it doesn't.

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

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

The description clearly states a specific action ('Stop a running crawl') on a specific resource ('crawl started by ``crawl``'), which distinguishes it from sibling tools like crawl and crawl_status. The verb and resource are 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 implies when to use (for crawls started by `crawl` that are still running) and provides a clear context. However, it does not explicitly mention alternatives or when not to use, such as checking status first with crawl_status.

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 burden. It discloses the return fields but omits behavioral traits like idempotency, rate limits, or error handling. Adequate for a simple status poll, but minimal.

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?

Single sentence with inline code formatting. No wasted words; efficient and 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?

Given the single parameter and existence of an output schema, the description covers the basics. However, it could mention it is meant to be used after a crawl to poll progress, enhancing context completeness.

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

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

Schema description coverage is 0%, so description must compensate. It mentions polling 'by id' and the parameter is named 'task_id', making the mapping clear. No additional syntax or constraints provided, but sufficient for a single parameter.

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

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

The description clearly states it polls a crawl task by id and returns status, pages, and error, distinguishing it from sibling tools like 'crawl' for initiating tasks. However, the verb 'poll' could be more explicit about checking status after initiation.

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 on when to use this tool versus alternatives (e.g., 'crawl' for starting a task, 'search' for searching). It is implied for checking status after a crawl, but lacks explicit when-not or prerequisites.

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

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

Describes core behavior (write to file, no vectors) but does not disclose side effects (e.g., read-only, no modification of original data). No annotations provided, so description carries burden but only partially addresses it.

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-loaded with main purpose and parameters. No wasted 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?

Covers main purpose and two parameter details, but lacks usage context and behavioral safety. Output schema exists (not shown) so return values not needed. With no annotations, description is adequate but not thorough.

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

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

Explains fmt (parquet/jsonl, infers from suffix) and source (limits to one file) but does not describe output parameter beyond being the file path. Schema coverage is 0%, so description adds some value but leaves gaps.

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?

Clearly states the tool writes a per-page dataset to a file, specifies no vectors, and implies export action. Distinguishes from import_dataset (sibling) by nature of operation.

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

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

Implies use for exporting dataset to file in parquet/jsonl optionally limited to one source. No explicit when-to-use or alternative guidance, but context suggests it's for file output.

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 provided, so the description carries the burden. It clearly indicates a read-only operation listing GPUs with memory info. No destructive or side effects are suggested, and the behavior is transparent for such a simple tool.

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

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

The description is a single sentence that conveys all necessary information without extraneous words. It is perfectly sized for the tool's simplicity.

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

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

With no parameters and an output schema present, the description fully covers the tool's purpose and behavior. It explains what is listed and provides an equivalent API reference, leaving no gaps.

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?

There are zero parameters, so schema coverage is 100%. The description adds meaningful context about the return values (free/total VRAM) beyond the schema, justifying a baseline of 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 clearly states it lists detected GPUs with free/total VRAM, and provides the equivalent HTTP endpoint. This distinguishes it from sibling tools which are unrelated to GPU listing.

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

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

The description implies this tool is for checking GPU availability, but does not explicitly state when to use it versus alternatives or any prerequisites. However, due to its simplicity (no parameters), usage is largely self-evident.

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 correctly implies a read-only operation without side effects. It does not specify edge cases but is adequate for a simple getter.

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, succinct sentence that front-loads the key action and resource. No wasted 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 read tool with no parameters and an output schema, the description provides all necessary context: it returns the current effective placement. No gaps.

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?

There are no parameters, so schema coverage is 100%. The description adds no parameter-specific value, so 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 clearly states the tool's purpose: 'Show the current effective multi-GPU model placement.' It uses a specific verb ('Show') and resource ('multi-GPU model placement'), and distinguishes itself from siblings like set_placement and clear_placement.

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?

While no explicit when/when-not guidance is given, the tool's purpose is straightforward and the name implies its usage relative to siblings (set, clear, preview). Context is clear enough for an agent to infer when to use this tool.

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

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

With no annotations, the description carries the full burden. It discloses key behaviors: replaces existing copies and detaches imported sources from sync. However, it lacks details on authorization, rate limits, or potential side effects on other data.

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

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

Two concise sentences with no fluff. The first sentence states the primary purpose, and the second adds essential behavioral context. Front-loaded and efficient.

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

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

Given the presence of an output schema and the tool's moderate complexity, the description covers the main action, replacement, and detachment. It lacks details on re-embedding process and prerequisites but is generally sufficient.

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

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

Schema coverage is 0%, so the description must compensate. It partially explains the 'dataset' parameter (the dataset to import) but does not mention the 'fmt' parameter at all, leaving its purpose unclear.

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 imports a per-page text dataset and re-embeds it under the current model. It distinguishes the tool from siblings like export_dataset by specifying the action and additional behavior of replacing copies and detaching sources.

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

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

No explicit guidance on when to use this tool versus alternatives (e.g., crawl, add). The description does not specify prerequisites or preferred contexts.

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 discloses the initialization and session switching behavior, but does not address idempotency, error cases, or effects if the knowledge base already exists. No annotations are provided to supplement.

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 extremely concise with two clear sentences, no redundancy, and the key behavior 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?

The description covers the basic purpose but lacks details on prerequisites, error cases, and integration with other tools. The presence of an output schema may compensate for return values, but overall completeness is limited.

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 description adds the default behavior for an empty path beyond the schema's simple string type, but does not detail valid paths, error conditions, or other constraints. Given 0% schema coverage, more parameter detail would improve.

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 initializes a local .lilbee/ knowledge base and switches the session, with default to cwd. This specific verb+resource distinguishes it from sibling tools like search or sync.

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 should be used before other calls to set the session knowledge base, but lacks explicit when-not-to-use guidance or comparisons with alternatives.

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. It does disclose the pagination model and the limit range (1-1000), implying a safe read operation, but says nothing about offset behavior, default limits, or what the page envelope looks like.

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

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

A single compact sentence with the resource and pagination constraint front-loaded and no filler. It is efficient, though bordering on under-specified rather than merely concise.

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?

An output schema exists, so return structure needn't be explained, and the read-only list nature is simple. However, with low parameter coverage and no annotations, the missing offset semantics and default paging behavior leave a real gap.

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

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

With schema description coverage at 0%, the description must compensate for both parameters. It does constrain limit to 1-1000, adding real meaning, but offset is left completely undefined 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?

States a specific verb (List) and resource (documents), and adds that chunk counts are returned along with pagination. It is clear enough to distinguish from unrelated siblings like add, remove, and search, but does not explicitly contrast itself with any near-neighbor.

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?

Contains no guidance on when to use this tool versus alternatives such as search or catalog_browse, and no prerequisites or exclusions are stated. The agent must infer its role from the name alone.

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

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

With no annotations, description carries full burden. It explains filter parameters but does not disclose results format, pagination, performance, or any side effects. Minimal behavioral context beyond basic functionality.

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 clear front-loading. Every word adds value, no 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?

Tool is simple and output schema exists, so description is mostly complete. Provides necessary filter context. Could benefit from brief note on result limitation or ordering, but adequate for a list operation.

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

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

Schema description coverage is 0%, so description must compensate. It defines 'source' as native/remote and 'task' as filter by role, adding meaning but remaining somewhat vague (e.g., 'role' not defined). Partial compensation.

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?

Explicitly states 'List installed models' with clear verb and resource. Distinguishes from sibling tools like 'search' or 'sync' by focusing on listing installed models with filtering options.

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

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

No explicit guidance on when to use this tool versus alternatives. The description implies listing usage but does not mention exclusions or compare with siblings like 'search' or 'crawl'.

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 behavioral burden. It usefully discloses progress streaming, the meaning of source, and that allow_unsupported overrides an architecture refusal (a notable safety bypass), but omits auth/permission requirements, error behavior, and where the download lands.

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

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

The core action is front-loaded in the first sentence, followed by two terse parameter notes. Nearly every clause earns its place, though the doubled backticks are a formatting artifact.

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?

An output schema exists so return values need not be described, and the source/override semantics are covered. However, for a mutation-style download with 0% schema coverage and no annotations, missing prerequisites and failure behavior leave it only adequate.

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

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

Schema description coverage is 0%, so the description must compensate. It meaningfully explains two of three parameters (source native=GGUF/remote=SDK, allow_unsupported override), but the required model parameter receives no explanation at all.

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 ("Download a model") plus a secondary behavior ("stream progress"). It is clearly distinguishable from siblings like model_show (inspect), model_rm (remove), and model_list (enumerate).

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?

There is no explicit when-to-use or when-not-to-use guidance and no routing to alternatives. The source and allow_unsupported notes hint at configuration choices, but the agent is left to infer the appropriate context for invoking a pull.

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. It discloses the destructive nature (remove) and the limitation to certain sources, but lacks details on whether removal is irreversible, permissions needed, or any confirmation steps.

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?

Description is very concise at two sentences, front-loading the purpose. It earns its keep by covering scope and limitations, but could be slightly more structured for clarity.

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

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

Given the simple nature of the tool (removal with two params) and presence of output schema, the description covers the core action and constraints. However, it lacks parameter descriptions, which is a notable gap for completeness.

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 has 0% description coverage and the description adds no explanation for the 'model' and 'source' parameters. The description does not clarify what values are expected or how 'source' affects behavior, leaving a significant gap.

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

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

Description clearly states 'Remove an installed model' with a specific verb and resource. It distinguishes from siblings by specifying it only works on native GGUF models from 'lilbee' (likely a typo for 'libbee' or similar), and notes that Ollama/LM Studio models are read-only.

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

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

Provides clear context for when to use (removing models) and an exclusion (Ollama/LM Studio models are read-only). However, it does not mention alternatives for removing other model types or any prerequisites.

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

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

No annotations are provided, so the description carries full burden. It only says 'Show catalog and installed metadata' without disclosing side effects, permission needs, rate limits, or what exactly 'catalog and installed metadata' entails. The minimal description leaves the agent guessing about 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?

A single sentence that is concise and to the point. While it lacks detail, it is not overly verbose. Every word contributes to stating the tool's basic function.

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 low complexity (1 parameter, output schema exists), the description is minimally adequate. It explains the basic purpose but omits details about return values, parameter semantics, and how it differs from similar tools. The output schema reduces some burden, but more context would help.

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 required parameter 'model' has no description in the input schema (0% coverage). The description does not clarify acceptable values, format (e.g., name, ID, path), or constraints. No additional meaning is provided beyond the schema's type string.

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

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

Description uses verb 'Show' and resource 'catalog and installed metadata for a model ref,' clearly indicating the tool's function. It is specific enough to distinguish from siblings like 'model_list' (which lists models) and 'model_pull' (which downloads). However, it does not explicitly differentiate from similar inspection 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 on when to use this tool versus alternatives like 'model_list' or 'search.' No exclusions or prerequisites mentioned. The description simply states the action without contextual hints.

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

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

No annotations provided, so description carries burden. States 'No changes made' which signals non-destructive preview. Does not disclose permissions, rate limits, or error behaviors.

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, direct sentences. No unnecessary words. Could be slightly more informative without harming 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?

Adequate for a simple preview tool with one optional parameter and output schema. However, lacks explanation of the output or any error conditions.

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

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

Schema coverage is 0%, so description must add meaning. Only says 'placement spec (or auto, when omitted)', which clarifies that the object represents a placement spec but provides no structure or constraints for the parameter.

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

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

Clearly states verb 'preview' and resource 'placement spec'. Indicates non-mutating behavior ('No changes made'). Lacks explicit differentiation from siblings like 'clear_placement' but distinct enough.

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

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

Description implies safe preview usage via 'No changes made', but no explicit guidance on when to use vs alternatives like 'add' or 'clear_placement'.

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 behavioral burden and does well: it states that source files are never deleted and spells out the destructive scope of folder removal ('everything indexed beneath it') and glob matching. It omits permissions, idempotency, and what happens on non-matching patterns, but the safety profile of a 'remove' tool is disclosed.

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 tight sentences plus a clarifying clause; the primary action is front-loaded and the safety caveat follows immediately. No filler or restatement of the tool name.

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?

An output schema exists, so return values need not be described, and the single parameter's meaning is covered. Remaining gaps are minor: no auth/permission requirements and no note on behavior when a pattern matches nothing.

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

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

Schema description coverage is 0% and the schema only declares an array of strings, so the description must compensate. It does, by explaining that entries may be source names, folder paths, or glob patterns and defining glob syntax (*/?/[]). It does not explain how multiple entries combine or path resolution rules.

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 (remove) and resource (documents from the index) and pins down the three selection modes (source name, folder, glob), which separates it from broad-wipe siblings such as reset or wiki_wipe. It also clarifies the blast radius up front with 'Source files are never deleted'.

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 semantics of each selector (folder vs glob vs name), but there is no explicit when-to-use or when-not-to-use guidance and no named alternative (e.g., list_documents to inspect first, reset for a full wipe). An agent can infer intent but gets no routing help.

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 description carries full burden. It discloses destructive behavior (delete all documents and indexed data) and the confirm requirement. But lacks details on reversibility or side effects.

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

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

Two concise sentences with no fluff. Every part provides essential 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 simple destructive tool with one parameter, the description covers the core function and key requirement. Does not mention output, but completeness is reasonable given 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?

Only one parameter (confirm) with 0% schema coverage. Description compensates by stating it requires confirm=true, adding meaning beyond the boolean type.

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

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

Description clearly states 'Factory reset: delete all documents and indexed data', using a specific verb and resource. It implicitly distinguishes from sibling tools like 'settings_reset' by indicating a full reset.

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?

States the requirement 'Requires confirm=true', which is a usage constraint. However, it does not provide guidance on when to use this tool versus alternatives like 'settings_reset' or 'remove'.

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?

Describes return format (chunks with citations) and scope semantics. No annotations provided, so description carries full burden; lacks details on top_k range or rate limits, but adds useful context beyond schema.

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

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

Two sentences plus a scope note; no fluff. Front-loaded purpose and guidelines.

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?

Covers purpose, usage, scope, and output format. Lacks top_k default/range and any mention of permissions, but given output schema exists, it's sufficiently complete.

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

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

Schema has 0% coverage, so description compensates by explaining scope values and default. Query is assumed, top_k is not explained but is self-explanatory. Still, partial coverage justifies 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 clearly states the tool searches indexed documents, code, and crawled pages, distinguishing it from web-fetch or file-read tools. It specifies the verb and resources, with a clear preference note.

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

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

Explicitly recommends this tool over web-fetch or file-read, and clarifies scope usage with default values and wiki limitation. Missing when-not-to-use conditions.

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 usefully discloses persistence to config, the auto-placement of omitted roles, and that tensor_split defaults to an even split. It does not say whether changes apply immediately, require a reload/restart, or how they interact with existing placements, which are meaningful gaps for a mutating tool.

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

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

Front-loaded with the core action and persistence note, then a compact example and two clarifying clauses. Every sentence earns its place; nothing is redundant.

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?

Output schema exists, so return values need not be described. The high-complexity nested payload is well documented. Only minor behavioral details (apply timing, reload requirement, override semantics) are absent for a no-annotation mutation tool.

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

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

Schema coverage is 0% and the sole param 'spec' is an opaque bare object, so the description does all the work: it gives the role→placement shape, a concrete example, and the meaning/default of 'devices' and 'tensor_split'. This fully compensates for the schema and is exactly what an agent needs to build the payload.

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 ('Set and apply a manual multi-GPU placement spec') with the added scope qualifier that it persists to config. Together with the role-mapping explanation, an agent can distinguish it from get_placement/preview_placement/clear_placement without opening 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?

Usage is implied rather than stated: 'manual' placement and 'persists to config' signal this is the durable counterpart to preview_placement/get_placement, but the description never explicitly says when to prefer it over those siblings or whether preview should be run first. Adequate but leaves routing to inference.

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

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

No annotations are provided, so the description bears full responsibility for behavioral disclosure. It only states the tool gets a value and metadata, but fails to mention side effects, auth requirements, rate limits, or behavior when the key does not exist.

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 very concise at one sentence, front-loading the core purpose. However, it sacrifices valuable detail that could be included without becoming verbose.

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

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

Given the presence of an output schema (not detailed here), the description does not need to elaborate on return values. However, with only one parameter and no parameter description, along with missing usage guidelines and behavioral context, the description falls short of being fully complete for an agent to use effectively.

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

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

With 0% schema coverage for the 'key' parameter, the description adds no additional meaning beyond the parameter name. It does not explain what constitutes a valid key, how to obtain it, or any format constraints.

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

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

The description clearly states the verb 'Get', the resource 'a single setting', and the output 'current value + metadata'. This distinctly separates it from sibling tools like settings_list (list multiple) and settings_reset (reset).

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

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

No guidance is provided on when to use this tool versus alternatives, such as when to use settings_get over settings_list or other tools. There are no context signals or exclusions mentioned.

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 discloses the output fields (value, default, type, help, choices) and parameter behavior. Despite no annotations, it gives sufficient transparency for safe usage.

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 succinct lines, front-loaded with the main purpose, and each word adds value. No redundancy or waste.

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

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

Given the tool's simplicity (single optional parameter, list operation), the description covers output structure and parameter behavior. No missing critical details like authentication or pagination, which are likely not needed.

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 'group' has zero coverage in schema but the description adds full semantics: filtering behavior, case-insensitivity, and default when empty. This compensates well for schema gaps.

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 ('writable lilbee settings'), with specific details about output fields. The name and description distinguish it from siblings like settings_get and settings_reset.

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 explains the optional group parameter's behavior (case-insensitive filter, empty returns all), providing clear context for when to use it. While it doesn't explicitly contrast with sibling tools, the purpose is clear enough.

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 mentions 'writable settings' implying read-only settings cannot be reset, but it fails to clarify that only specified keys are reset (contradicted by the required 'keys' parameter which suggests per-key operation). No annotations exist, so the description must carry all behavioral info but is incomplete.

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, which is efficient. However, it lacks additional structure (e.g., bullet points) that could improve readability, but given the simplicity, it is appropriately sized.

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

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

Given the number of sibling tools and no annotations, the description should provide more context about scope (e.g., does it reset all writable settings or only specified ones?), but it does not. The existence of an output schema partially mitigates the need to describe return values, but overall the description is incomplete for a complex tool ecosystem.

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

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

Schema description coverage is 0%. The description does not mention the 'keys' parameter at all, leaving its purpose and format entirely undocumented. The tool's behavior is implied as resetting settings, but how to specify which settings is missing.

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 ('Reset') and resource ('writable settings') with the outcome ('built-in defaults'). It clearly distinguishes from sibling tools like settings_list (read) and settings_get (read single), as reset is a mutation action.

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 on when to use this tool versus alternatives. For example, it does not explain when a reset is appropriate compared to updating individual settings via other tools, nor does it mention any prerequisites or side effects.

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 bears the full burden and carries it well: it discloses atomicity, rollback-on-validation-error behavior, that changes persist to config.toml, and even the key return fields. It does not cover authorization requirements or what happens to settings not named in the update set, which keeps it short of a 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?

Two tight sentences, front-loaded with the operation's defining trait (atomicity) and followed by persistence and return shape. No filler or restatement of the tool name.

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?

An output schema exists, so the mention of updated/reindex_required/warnings is a bonus rather than a necessity. The real gap is on the input side: for a nested, untyped object parameter the agent has no way to know valid keys or values from either the schema or the description.

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

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

Schema coverage is 0% for the single 'updates' parameter, which is an untyped free-form object. The description says only 'update writable settings' and never enumerates which settings are writable or what keys the updates object accepts, so the critical parameter remains undocumented in both places.

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 ('atomically update writable settings') and adds a meaningful qualifier ('writable') that separates it from the read-side siblings settings_get/settings_list and from settings_reset. It never names a sibling explicitly, so an agent must infer the boundary rather than being routed, but the purpose itself 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?

There is no when-to-use guidance and no mention of the closely related settings_reset, settings_get, or settings_list siblings. The atomic/rollback clause hints that this is the safe path for multi-key changes, but that implication is never stated as a selection rule.

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. It does not state that this is a read-only/non-mutating operation, nor anything about permissions, cost, or behavior when an upgrade is not running. The mention of 'the running upgrade' hints at conditional output but is not explained.

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 compact sentence with the subject front-loaded. It is efficient, though the trailing 'or the running upgrade' adds ambiguity rather than clarity about what selects each output.

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?

An output schema exists and there are no parameters, which lowers the disclosure burden, but the description presents multiple possible outputs without explaining what determines which one is returned. For a diagnostic tool with this many overlapping siblings, that ambiguity leaves the agent short of what it needs to invoke confidently.

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 takes zero parameters, so there is nothing for the description to clarify; the baseline of 4 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 names concrete things it reports (document counts, config, chunk counts, running upgrade), so the purpose is inferable, but the verb and scope are fuzzy and it gives no signal distinguishing it from siblings like model_show, wiki_status, or crawl_status. An agent could not confidently pick this over those without opening schemas.

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

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

There is no statement of when to call this versus the numerous other status-like siblings (wiki_status, crawl_status, model_show) or any prerequisites. Only implied usage at best.

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 behavioral burden, and it does disclose real destructive semantics: prune_ignored drops sources, force_rebuild re-ingests everything. However, it omits default (incremental?) behavior, permission/auth requirements, and whether the drops 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?

Purpose is front-loaded in one sentence, then three tight clauses map directly to the boolean flags. Every sentence earns its place with no 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?

An output schema exists, so return values need not be explained, and the destructive flags are covered. It is close to complete for a 5-param mutation tool, missing only default incremental behavior and any auth/permission note.

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 20% (ocr documented, ocr_timeout not), so the description must compensate, and it does: it explains force_rebuild, retry_skipped, and prune_ignored with concrete meaning. Only ocr_timeout remains undocumented in both places, keeping it from a 5.

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

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

The first sentence gives a specific verb+resource+destination: 'Sync the documents directory into the vector store.' It clearly distinguishes this from sibling ingest paths like crawl and add. It stops short of explicitly naming those siblings, so it earns a 4 rather than 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?

The description never states when to reach for sync versus crawl, add, import_dataset, or list_documents. The flag explanations describe modes of this tool, not selection criteria against alternatives. Usage is only implied by the tool name.

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

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

With no annotations, the description carries the behavioral disclosure burden. It discloses an important trait: it is registered even when the wiki is disabled, similar to an HTTP status route. This gives context about availability and what the tool can reveal, which is sufficient for a status check tool.

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

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

The description is two sentences, with the main purpose front-loaded clearly in the first sentence. The second sentence adds a meaningful caveat about disabled state without unnecessary elaboration. No wasted 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?

Given the output schema exists, the description need not explain return values. It covers the essential purpose and the notable behavior about disabled state. It could mention what the response looks like, but for a simple status tool this is sufficient.

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 has zero parameters, so schema coverage is trivially 100%. The description correctly omits parameter details. Baseline for a zero-parameter tool is 4, and no additional explanation is needed.

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: 'Show wiki layer status' with specific contents (page counts, recent lint issues). It distinguishes itself from sibling tools like 'status' by focusing on the wiki layer, and the name reinforces this specificity.

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 a key usage context: even when the wiki is disabled, this tool remains registered so callers can read the disabled state. This implies using this tool when you need wiki status regardless of enabled state, but it does not explicitly compare to alternatives like 'status'.

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 discloses that the tool deletes all generated wiki pages and their indexed rows, and that it requires confirmation (confirm=true). It also explains its availability even when the wiki is disabled, which is valuable behavioral context. With no annotations, this description carries the full burden and does a good job conveying the destructive and conditional nature.

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: the first states the action and requirement, the second provides rationale for the tool's availability. Every sentence adds value and it is front-loaded with the core purpose.

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 destructive tool with one parameter, the description covers the action, the confirmation requirement, and a specific use case (even when wiki disabled). It doesn't explain return values or permissions, but an output schema is present, so that's not required. The description is complete enough for an agent to select and invoke 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 schema only defines a boolean 'confirm' with no description, but the description explicitly instructs to 'Pass confirm=true,' clarifying the parameter's role and required value. This adds meaning beyond the schema, though it could further explain the behavior when confirm is false.

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 'Delete every generated wiki page and its indexed rows.' This is a specific verb (delete), resource (wiki pages and indexed rows), and scope (every). It distinguishes the tool from siblings like 'remove' or 'reset' by focusing on generated wiki pages.

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 explains that the tool is 'Registered even with the wiki disabled, because turning the setting off leaves the pages generated earlier in place,' providing clear context for when to use it. It also instructs to 'Pass confirm=true,' indicating the required action. However, it doesn't explicitly mention when not to use it or name alternative tools.

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