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

With no annotations, the description fully discloses that the tool is 'HEAVY', consumes compute, and may load the model. This provides essential behavioral context an agent needs to decide invocation.

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 sentences, each adding unique value: purpose, heaviness warning, and provider behavior. No redundant 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?

The description explains inputs and output metrics (latency, throughput) with units. However, lacking an output schema, it could have specified the exact return format or structure. Still, it provides sufficient context for an agent.

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?

While the schema has 100% coverage, the description adds meaning by explaining that prompt is optional with a default, and that maxTokens defaults to 64. It also contextualizes the tool's use of these parameters in benchmarking.

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 performs a benchmark by running real inference, measuring latency and throughput. It specifies verb 'Runs' and resource 'inference', and distinguishes from sibling tools (e.g., list_models, complete) which serve different purposes.

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

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

The description mentions behavior without a provider argument but does not explicitly state when to use this tool vs alternatives. It lacks guidance on when not to use it, though sibling tools are clearly different.

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 covers: data locality ('data never leaves the machine'), streaming via MCP progress notifications, default streaming behavior (true), and first-detected-provider fallback. Missing error handling details, but core safety and flow are documented.

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?

Four sentences, each purposeful: labeled purpose, usage warning, parameter guidance, streaming behavior. Front-loaded with bold 'DELEGATED INFERENCE:' for quick scanning. No unnecessary words.

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

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

Lacks description of return value (e.g., completion text or stream chunks). With no output schema, this is a gap. Otherwise covers key aspects: purpose, usage, streaming. Moderate complexity (8 params) handled well but incomplete on response format.

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%, baseline 3. Description adds significant value: clarifies that prompt and messages are alternatives, explains default provider behavior, and details streaming mechanics (progressToken, default true). These enrich schema definitions without redundancy.

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 explicitly states 'DELEGATED INFERENCE: Offload a text/chat completion to a local model runtime' with a clear verb and resource. It distinguishes from sibling tools like 'embed' or 'suggest_model' by specifying local model runtime and non-user-chat nature.

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?

Includes a clear exclusion: 'This is NOT a chat feature for the user.' Specifies alternative inputs ('Provide either prompt or messages') and default provider behavior. Lacks explicit comparison to sibling inference tools like 'embed' or 'suggest_model', but context makes role clear.

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 mentions cost savings and privacy but fails to disclose output format, rate limits, or any destructive/reversible behavior. For a delegated operation, more detail is needed.

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

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

Two sentences, each purposeful. The caps-lock phrase 'DELEGATED EMBEDDINGS' is slightly distracting but not harmful. The description is efficiently 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?

No output schema, yet description does not explain return values (e.g., shape of embeddings). With array input and multiple providers, the output semantics are non-trivial and should be clarified. Missing information limits 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 coverage is 100%, so baseline is 3. The description adds value by clarifying input types ('single string or array') and the default behavior for the provider parameter. This goes beyond the schema.

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

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

The description clearly states it generates embeddings by offloading to a local runtime, using verbs like 'offload' and 'embedding generation'. It distinguishes from siblings like 'complete' (text generation) and model management tools.

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

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

The description provides guidance on the optional provider argument defaulting to the first detected provider, but lacks explicit when-to-use vs alternatives. It does not compare with siblings like 'complete' or other embedding options.

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

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

No annotations exist, so the description carries full burden. It discloses the algorithm (resolve weight, estimate KV-cache, compare against free memory) and return fields (fits, target, bytes). However, it does not mention potential network calls for provider lookup or permission requirements, which are minor omissions for a read-only check.

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 sentences front-load the main purpose, then detail the process and return values. No wasted words; every sentence contributes 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?

With no output schema, the description explains return values (fits, target, bytes). Parameter count (5) with full schema coverage means schema handles details. The description is sufficiently complete for a non-mutating tool, though it could mention potential network dependencies.

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

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

Schema description coverage is 100%, so the schema documents parameters. The description adds value by explaining behavioral aspects like sizeBytes overriding lookup, contextLength default (4096), and parameterSize overriding lookup for KV estimate. This goes beyond the schema but could detail provider enum options.

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 determines if a model fits on local hardware, specifying the algorithm including weight resolution, KV-cache estimation, and memory comparison. It distinguishes itself from sibling tools like load_model or model_info by focusing on hardware fit check.

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 for checking model fit before loading, but does not explicitly state when to use this tool vs alternatives (e.g., load_model, suggest_model). No when-not or alternative guidance is provided, leaving usage context ambiguous.

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 full burden. It discloses that the tool performs a reachability check and version report, which is sufficient for a read-only operation. No misleading or missing behavioral traits.

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

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

Two sentences with zero extraneous text. The purpose is front-loaded and every phrase adds 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?

Given no output schema and a single optional parameter, the description fully covers what the tool does and how to use it. No gaps remain.

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 description adds value by explaining the default behavior when the provider parameter is omitted, which is not evident from the schema alone.

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 ('Check') and resource ('each provider's local runtime'), and clearly distinguishes from sibling tools like 'list_providers' by stating it also reports version and reachability.

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 when to omit the provider parameter ('Without a provider arg, checks all configured providers'), providing clear context. However, it does not explicitly state when to use this tool versus alternatives like 'list_providers' for simply listing providers.

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 full burden. It clearly describes the tool's behavior (listing loaded models, aggregating when no provider specified). It does not mention side effects or permissions, but for a listing tool the description is transparent enough.

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

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

Two sentences, no filler, front-loaded with the core purpose. Every word adds value.

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 list tool with one optional parameter and no output schema, the description is complete. It explains the core functionality, parameter behavior, and return structure hint, fully covering what an agent needs to use the tool 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 already provides an enum and description for the 'provider' parameter. The description adds significant value by explaining the aggregation behavior when the parameter is omitted, including the return structure ('keyed by provider'), which goes beyond the schema.

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

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

The description clearly states the tool lists models loaded into memory on each detected provider. It distinguishes itself from sibling tools like list_models (likely lists available models) and list_providers (lists providers), making its specific resource and action 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?

The description explains that without a provider argument, it aggregates results across all providers keyed by provider. This implies when to use the tool with and without the parameter, but it does not explicitly state when to use this over alternatives like list_models or model_info.

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. It discloses aggregation behavior but no other traits like caching, network calls, or auth needs. Adequate for a simple read tool, but could be more transparent.

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

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

Two sentences, front-loaded with purpose, followed by parameter behavior. Every sentence adds value with zero 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?

No output schema, so description should hint at return format. It says 'keyed by provider' but not what each entry contains. Lacks details on whether models are installed, available, or both. Adequate for simple tool but leaves 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 covers provider with enum and description. Description adds value by explaining behavior when parameter omitted (aggregation) and output format (keyed by provider), beyond schema's 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?

Description clearly states it lists models per provider, with specific verb 'list' and resource 'models installed/available on each provider'. Effectively distinguishes from siblings like list_loaded and list_providers by specifying scope of 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?

Provides guidance on when to omit the provider arg (aggregation) but lacks explicit guidance on when to use this tool over alternatives like list_loaded or model_info. Usage context is implied but not fully explicit.

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

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

No annotations provided; description fully discloses read-only nature and output fields (host, detected/live, capabilities). No side effects or permissions needed; sufficient for a list 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?

Single sentence concisely covers purpose, output, behavior, and optional filtering. No wasted words, front-loaded with key 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?

Complete for a simple list tool with one optional parameter and no output schema. Covers return fields and filtering, leaving no gaps for agent to decide invocation.

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

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

Schema coverage 100%, so baseline 3. Description adds meaning by clarifying the single optional parameter filters to one provider, enhancing schema's 'Optional provider id to filter to'.

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 the tool lists configured model runtime providers with details (host, live status, capabilities). It distinguishes from sibling tools like list_models (lists models) and list_loaded (loaded models).

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?

Describes when to use (list providers with status/capabilities) and optional filtering. Lacks explicit exclusion or alternative guidance, but context from sibling tools makes usage clear.

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?

Discloses key behavior (loading into memory, keepAlive, provider default) but omits details like idempotency, errors, authentication needs. No annotations 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?

Two concise sentences, front-loaded with core purpose, no filler.

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

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

Adequate for a loading tool: covers main behavior and options. No output schema needed. Could mention return status or loading duration, but not essential.

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?

Adds meaning beyond 100% schema coverage: keepAlive format hint and provider default behavior. Baseline 3, plus additional context.

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 'load', resource 'model', and purpose 'ready for inference'. Distinguishes from siblings like unload_model, list_models.

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 context for provider argument ('without a provider arg, loads on every detected provider'), but lacks explicit when-not-to-use or alternatives like complete/embed.

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 full burden. It discloses that the tool queries all providers if no provider arg is given and lists the metadata returned. This is sufficient for a read-only inspection tool, though it doesn't mention potential latency or caching.

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

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

Two sentences, front-loaded with key action and resource, no redundant words. Every sentence adds 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?

Given no output schema, the description adequately lists the metadata fields. However, it could mention the output format (e.g., JSON object) and edge cases (e.g., model not found). Still, for a simple info tool, it is largely 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 covers all parameters with descriptions, but the description adds distinct value by explaining that omitting the provider arg queries all detected providers, clarifying behavior beyond the schema's enum list.

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 specific verb 'show' and resource 'detailed metadata for a specific model', listing exact fields (family, parameter size, quantization, context length). It distinguishes from sibling tools like list_models (list all) and suggest_model (recommendations) by focusing on single-model details.

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 clearly states the tool is for inspecting a specific model and mentions the provider argument behavior. However, it does not explicitly state when not to use it (e.g., if you need a list, use list_models instead), leaving some inference to the agent.

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 includes a clear warning about downloading multiple gigabytes and long duration, which is critical for this heavy operation.

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

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

Two concise sentences, no wasted words. The warning is front-loaded and the usage condition is clear.

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 complexity (heavy download), absence of annotations, and no output schema, the description adequately covers behavioral warnings, parameter usage, and default behavior, leaving no critical 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 coverage is 100%, so baseline is 3. The description adds little extra meaning beyond the schema's descriptions for model and provider, though the note about no provider pulling on all providers is relevant but more about usage.

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 explicitly states the action ('Download/pull') and resource ('a model onto a provider'), and the warning about size and time clearly distinguishes it from sibling tools like unload_model or remove_model.

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 omitting the provider arg applies to all detected providers, but does not explicitly differentiate from similar tools like load_model, which might be confused with pulling.

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 clearly labels the action as 'DESTRUCTIVE,' states permanence, and explains the required confirm flag and provider scoping.

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

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

Two concise sentences front-load the critical information: destructive nature and required confirm/providers. No unnecessary words, highly 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?

For a destructive tool with 3 params and no annotations, the description covers key behavioral aspects but could mention whether deletion also unloads a currently loaded model or describe 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 100%, providing baseline 3. The description adds extra context for the provider parameter (prevents fan-out deletion) and the confirm parameter (required for action), enhancing understanding beyond the schema.

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

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

The description clearly states the tool 'permanently delete a model from a provider,' using a specific verb and resource. It distinguishes itself from the sibling 'unload_model' by emphasizing permanence and destruction.

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

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

The description provides important safety guidelines (require confirm:true, provider is required to prevent fan-out) but does not explicitly compare to alternatives like unload_model or list when not 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 provided, the description carries full burden. It transparently discloses that the tool searches a curated static subset rather than the full live library, which is a key behavioral trait. No mention of auth or rate limits, but those are less relevant for a search 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 no fluff: first sentence states the purpose, second adds an important caveat. Every word earns its place.

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

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

Given a simple 1-parameter tool and no output schema, the description adequately covers the purpose and key constraint. It could be more complete by hinting at the return format (e.g., list of model objects), but it remains sufficient for basic usage.

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 description of the query parameter in the schema is already clear. The description adds no new information about the parameter beyond what is in the schema, so it meets the baseline but does not enhance understanding.

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 (search), resource (built-in catalog of well-known local models), and criteria (by name, family, or task). It effectively distinguishes this tool from siblings like 'list_models' which lists all models, by specifying it searches a curated static catalog.

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

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

The description provides useful context by noting that this is a curated static catalog, not the full live Ollama library, with a link to the live library. However, it does not explicitly state when to use this tool versus alternatives or when not to use it.

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

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

The description discloses ranking behavior: by task match then memory fit, and mentions detection of free GPU VRAM or system RAM. Without annotations, this provides good transparency, though it could specify whether multiple GPUs are considered or what 'fit' means precisely.

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, directly states purpose and output. No wasted words. Front-loaded with the core verb 'Recommend'.

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 simplicity of one parameter and no output schema, the description covers all essential aspects: input (task), ranking criteria (task match, memory fit), and output (ranked list with fit flags). Leaves no major 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?

The single parameter 'task' is fully defined by the enum in the schema. The description adds context that the task is used for ranking models, which is a slight enhancement beyond the schema's label.

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 recommends local models for specific tasks, ranks by task match and memory fit, and returns a ranked list with fit flags. It distinguishes itself from sibling tools like list_models and fit_check by combining recommendation and system resource awareness.

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 using this tool for model recommendations but does not explicitly state when to prefer it over alternatives like list_models, fit_check, or search_available. No guidance on prerequisites or context.

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 implies a read-only, safe operation, but with no annotations, it lacks details on execution speed, side effects, or permission requirements. It does not contradict anything as there are no annotations.

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

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

Two sentences: one lists what is reported, the second provides the use case. No fluff; each sentence serves a 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 parameterless tool without output schema, the description fully covers the tool's purpose and the data it returns. It is complete enough for an agent to decide when to call it and understand the response.

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 zero parameters and 100% schema coverage, the description adds value by explaining the output content (platform, RAM, CPU, GPUs). The baseline for no params is 4, and the description meets that.

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

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

The description clearly states the tool reports local hardware resources, listing specific items (platform, RAM, CPU, GPUs). It distinguishes this tool from siblings like health_check or benchmark by focusing on static hardware info.

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

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

The phrase 'Used to reason about which models can run locally' provides clear context for when to use this tool. However, it does not explicitly discuss when not to use it or compare to sibling tools like fit_check.

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?

Description discloses the main effect (freeing memory) and default behavior with optional provider, but does not mention potential side effects (e.g., if model is in use) or reversibility. No annotations provided, so some burden remains unaddressed.

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, zero waste, front-loaded with the action. Every word serves a 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?

Given low complexity and no output schema, the description is complete: covers purpose, default behavior, and both parameters. No significant gaps for a simple unload tool.

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

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

Schema coverage is 100%, reducing burden. Description adds value by explaining default behavior of 'provider' parameter and clarifying 'model' as ID/name, which goes beyond schema descriptions.

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

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

The description clearly states the action 'Unload a model from memory to free VRAM/RAM' with specific verb and resource, and distinguishes from siblings like load_model or list_models by focusing on freeing memory.

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

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

The description provides context on when to use (to free memory) and specifies default behavior without provider arg, but does not explicitly state when not to use or compare to remove_model for permanent deletion.

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