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

With no annotations, the description carries the behavioral disclosure burden. It adds meaningful constraints: the path is resolved via realpath, symlink escapes are rejected, and the directory must already exist. This goes beyond a generic 'add' description and helps the agent predict failure 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 two concise sentences with no filler. The primary purpose is front-loaded, and the behavioral constraints are presented in a compact, readable way.

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 single-parameter tool with no output schema and no annotations, the description is sufficiently complete. It explains what the tool does, what input it expects, and the key constraints an agent must know to invoke it correctly.

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

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

The schema already covers the path parameter at 100%, so the baseline is 3. The description adds value by specifying realpath resolution, symlink escape rejection, and the existence requirement, enriching the semantics beyond the schema's simple 'Absolute or relative directory path to allow'.

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

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

The description states a specific action ('Grant') and resource ('a directory'), and clarifies the purpose ('for local Cursor agent file writes'). This clearly distinguishes it from sibling tools like remove_allowed_dir and list_allowed_dirs.

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 clear context for when to use the tool: when a directory needs to be granted for local Cursor agent writes. It doesn't explicitly name alternatives, but the sibling tool names and the 'Grant' verb make the intended usage obvious.

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 the critical behavioral consequence: before approval no writes happen, after approval only the allowlisted cwd is writable. It also mentions that an optional comment is stored. This is meaningful context beyond the schema. It doesn't cover error handling or rejection side effects, but the key behavior is well captured.

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 zero waste. The purpose is front-loaded, and the behavioral consequences are stated in a compact, easily parseable manner. Every sentence earns its place.

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

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

For a mutation tool with no annotations and no output schema, the description covers the pre/post conditions and the allowlist constraint. It doesn't enumerate edge cases like what happens on a reject or if the thread has no pending approval, but those are predictable from the schema and the overall tool interaction. The essentials are covered.

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 67% (thread_id and comment have descriptions; decision has only an enum but that is self-explanatory). The description adds context about pendingApproval and the approval flow, but does not add param-specific details beyond what the schema already provides. It stays at the baseline for adequate coverage.

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 is explicit: 'Approve or reject pending implement/install actions from chat_send.' It names the resource (pending actions) and the specific verb (approve/reject), and it clearly differentiates from siblings like chat_send and run_workflow by focusing on the approval gate.

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 pre- and post-approval behavior ('Until Approve, Cursor stays plan-only... After Approve, the closer may write only inside the allowlisted cwd'), which effectively tells an agent when to invoke this tool (when there is a pendingApproval). It does not explicitly mention when not to use it, but the context is clear enough.

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

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

With no annotations, the description must carry the full burden of behavioral disclosure. It does disclose that files on disk outside the chat store are not deleted, which is useful, and hints that 'Late' will wait for approval. However, 'Late' is unexplained, and the approval-waiting behavior is ambiguous – it does not clarify when it applies, what the approval flow looks like, or what the result is if approval is denied. Key behavioral aspects like reversibility and side effects on the chat thread are missing.

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 short and front-loaded with the core purpose, which is good. However, the sentence 'Late will wait for Approve.' is cryptic and disrupts the overall clarity. The scope boundary sentence is clear but the approval-related sentence needs expansion or rewording to be genuinely useful.

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?

This is a destructive/mutating operation with no annotations, no output schema, and only a one-line parameter schema. The description covers the file-system boundary but does not describe what 'wait for Approve' means, how an agent observes the approval outcome, or what the return/result of the deletion call looks like. It also doesn't clarify prerequisites (e.g., whether the thread must exist, or whether approval is always required or only for certain thread types).

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

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

Schema description coverage is 100%, and the schema already states that thread_id is a 'Chat thread id from chat_send or chat_list'. The description adds no further parameter meaning beyond the schema, so a baseline of 3 is appropriate. The phrase 'by id' in the description simply restates what the parameter name implies.

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 states a specific verb ('Delete'), a specific resource ('persisted GUI/MCP chat thread'), and the identifying method ('by id'). This clearly distinguishes it from sibling tools like chat_send, chat_list, and chat_get. The scope boundary about not deleting files outside the chat store further reinforces the precise purpose.

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 does not explicitly state when to use this tool versus alternatives like chat_approve or chat_get. The phrase 'Late will wait for Approve' hints at an approval interaction, but it is too cryptic to serve as practical guidance. No exclusions or alternative tool names are 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?

With no annotations provided, the description carries the behavioral disclosure burden. It clearly states that this is a read operation, reveals that busy=true is included while the debate/single is still running, and explains the non-blocking polling use case. It could mention error behavior or not-found cases, but the core runtime behavior is transparent.

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

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

Two dense sentences carry all the essential information with no filler. The primary purpose is front-loaded, followed by a concise behavioral note about busy polling. Every sentence earns its place.

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

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

For a single-parameter read tool with no output schema, the description covers the purpose, the contents of the response, and the polling behavior that matters to clients. It doesn't spell out edge cases like invalid thread_id, but the description is otherwise complete enough for an agent to call 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?

Schema description coverage is 100%: the only parameter, thread_id, is described as 'Chat thread id from chat_send'. The tool description does not add meaning beyond this, so the baseline score of 3 applies.

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

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

The description opens with a clear verb and resource: 'Read one chat thread', and specifies exactly what is included (messages, speakers, pending approval). It distinguishes itself from siblings like chat_list by emphasizing 'one' thread and by mentioning the busy polling behavior tied to chat_send.

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

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

The description gives practical usage context: clients can use chat_get to poll for busy=false while a debate/single is still running, instead of blocking on chat_send wait. It doesn't explicitly enumerate alternatives or exclusion cases, but the polling guidance makes the intended use 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?

With no annotations, the description carries the behavioral burden, and it does so adequately: 'List persisted...' clearly implies a read-only operation, and the parenthetical names the exact fields returned. It does not discuss ordering, pagination, or user scoping, but for a zero-parameter read-only list this is a minor gap.

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

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

A single front-loaded sentence that names the action, resource, and output fields with no filler. It is concise without being a tautology and every clause earns its place.

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

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

For a parameterless list tool with no output schema, mentioning the returned fields is sufficient for basic invocation. It could add ordering or clarify whether 'GUI/MCP' means two separate thread sources, but nothing critical is missing.

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

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

There are no parameters, so there is no missing parameter documentation to compensate for. The schema is fully covered by virtue of having an empty properties object, and the description adds no conflicting or misleading input semantics.

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

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

States a specific verb and resource — 'List persisted GUI/MCP chat threads' — and enumerates the returned fields (id, title, agents, updatedAt). The resource is distinct from sibling tools like list_agents and list_runs, so an agent can tell it apart without opening a schema.

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

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

No when-to-use guidance, exclusions, or references to alternatives are provided. The description does not help an agent decide between chat_list and related listing tools such as list_agents, list_runs, or list_local_models.

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 behavioral burden. It candidly discloses debate mode, pendingApproval gating, non-blocking Q&A/debate, file-write routing restrictions, and assistant-message metadata. This is unusually transparent about side effects and modes.

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 purpose sentence followed by dense, distinct behavior rules with no filler and no repetition of schema content. Every sentence adds a separate routing, blocking, or output fact.

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 nine-parameter tool with no output schema and no annotations, it covers routing, approval gating, blocking behavior, and response message fields. It does not state the exact return shape or how to retrieve/follow up on the resulting thread via chat_get/follow_up, leaving a small but 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?

Schema coverage is only 44%, and the description compensates richly for pin by extending the schema text with auto-router behavior. However, it is silent on cwd, branch, pr_url, repo_url, and extra_context, leaving several parameters underspecified 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?

Opens with a specific verb+resource+mechanism: 'Send a natural-language message through the same auto-router the GUI uses.' The routing detail makes it distinct from thread-reading, approval, and workflow-run siblings, even though it doesn't name them.

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

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

Gives explicit routing context: auto default, forced debate, single/backend pin, and when implement/install stays plan-only. It does not explicitly enumerate sibling alternatives or say when to use chat_get/chat_approve instead, so it stops short of a 5.

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

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

With no annotations, the description carries the full safety burden and does so thoroughly. It discloses the deletion scope, what is not deleted, a required confirmation flag, the stop-before-delete condition, an approval wait, and the fact that cwd/allowlist/write-directory/path parameters are not accepted.

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-loaded with the primary action, then covers prerequisites, edge cases, and exclusions. The phrase 'Extra calls wait for Late Approve' is terse and slightly unclear, but there is no substantive 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?

For a destructive tool with no annotations and no output schema, the description provides the necessary behavioral and safety context: what is deleted, the confirmation requirement, the serving-on-port condition, and the unsupported inputs. It does not specify success/error response details, but that is a minor gap for a delete 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 coverage is 100%, so the schema already fully documents model and confirm. The description restates the confirm requirement and characterizes model as a Hub org/model id, but adds no new parameter-level detail beyond the schema, so the baseline 3 is appropriate.

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

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

States a specific verb ('Remove'), a specific resource ('compiled late-infer snapshot'), and a scoped location ('compiled dir only, not the Hub cache'). This clearly distinguishes it from sibling tools like delete_local_model or pull_late_infer.

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 explicit preconditions: requires model id and confirm=true, and conditional behavior: stop first if serving on port 8010. It does not name alternative tools or say when this tool should not be used, but the scope exclusions ('not the Hub cache', 'does not delete bin/late-infer') make the intended use fairly 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?

With no annotations provided, the description carries the full burden, and it excels. It discloses permanence ('Permanently delete'), side effects ('Stops that model if it is running'), the safety requirement ('Requires confirm=true'), and the limitation ('Does not unregister other backends'). This is exactly the transparency needed for a destructive 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?

Three sentences, all front-loaded and necessary. The first sentence states the core action, the second covers side effects, the third covers preconditions and scope limitations. No filler or repetition of schema fields.

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

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

For a two-parameter destructive tool with no annotations and no output schema, this description is complete. It covers the action, side effects, safety gate, and scope exclusion. An agent has everything needed to invoke it correctly and to know what to expect after execution.

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

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

Schema coverage is 100%, so the baseline is 3. The description adds meaningful context by defining model_id as a 'downloaded snapshot' in the 'allowlisted models directory,' and by restating the confirm=true requirement in operational terms. This goes beyond the schema descriptions without duplicating them unnecessarily.

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 opens with a specific verb and resource: 'Permanently delete a downloaded snapshot from the allowlisted models directory.' This clearly distinguishes it from siblings like download_local_model, start_vllm, stop_vllm, and remove_vllm. An agent can immediately tell this tool is for deleting local model files, not for managing running backends.

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

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

The description gives clear context: it deletes downloaded snapshots, stops the model if running, and explicitly states it does not unregister other backends. This provides an implicit boundary between this tool and backend-managing siblings like remove_vllm. However, it does not explicitly name an alternative tool, so it falls short of a perfect 5.

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

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

With no annotations provided, the description carries the full burden of behavioral disclosure. It does disclose an important behavior: Cursor local backends can edit files only inside the write allowlist. However, it does not describe run lifecycle, asynchronous behavior, return values, or potential side effects like PR creation, which are relevant for a dispatch/mutation 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?

Two tight sentences: the first states purpose, the second provides routing guidance and a key constraint. No filler or repetition of schema content.

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

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

The tool is complex with 11 parameters, no annotations, and no output schema, so the description should supply more operational context. It covers purpose, routing, and one constraint, but omits what the agent can expect back from dispatch, when to poll, and how run results are surfaced. The wait and get_run schema hints help, but the description itself leaves those 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 100%, so the parameter list is already well-documented. The description adds minimal parameter-level meaning, mostly referencing the write allowlist constraint that affects cwd but not adding much 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 opens with a specific verb and object: 'Send a task to one specialist.' This clearly distinguishes dispatch from chat_send and run_workflow by emphasizing single-specialist task routing.

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 explicitly tells the agent to prefer chat_send for natural language because the orchestrator auto-routes, including round-table debate. It also adds a crucial constraint about Cursor local backends and the write allowlist, guiding when dispatch is appropriate.

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

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

With no annotations, the description carries the transparency burden and does well: it discloses the allowlisted destination, size implication, reliance on HF_TOKEN/HUGGING_FACE_HUB_TOKEN for gated repos, and the limited scope of dry_run. It does not mention overwrite behavior or return details, but the disclosed traits are meaningful.

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 short sentences deliver purpose, destination, warnings, auth, and dry_run behavior with no filler. The most important scoping information is front-loaded.

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

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

For a 3-parameter download tool with no annotations, the description is nearly complete: it covers destination, auth, and dry_run. It could add what the tool returns or whether it overwrites existing files, but nothing required for a safe first invocation is missing.

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

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

Schema coverage is already 100%, and the description adds value on top: it supplies the default destination directory, clarifies that model_id can be a catalog id or HF repo id, and explains dry_run semantics beyond the schema's one-liner.

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 precise operation: download a catalog model or HF repo into the allowlisted models directory, with a default path. This clearly separates it from local-model management siblings like delete_local_model or list_local_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?

It gives clear usage context: use it for large model downloads into the allowlisted directory, pass an explicit model_id, and use dry_run to validate the destination. It does not explicitly contrast with alternatives or state when not to use it, so it misses the full 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 behavioral disclosure burden. It usefully explains how different backends behave (cursor resumes the same agent; external backends continue with stored history), which goes beyond the schema. However, it does not mention return behavior, blocking semantics, or failure cases.

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 concise sentences that front-load the core purpose, then add backend-specific detail. No redundant phrasing or filler.

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

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

The description covers the central continuation behavior and backend differences, but leaves gaps: no output schema, no explanation of 'wait', and no indication of what response the agent should expect. For a three-parameter tool, this is acceptable but not 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 description coverage is only 33%, so the description must compensate, but it does not explain the 'message' or 'wait' parameters. run_id is minimally documented in the schema, but the description adds nothing about the meaning or expected format of the parameters.

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 with a specific verb ('Continue') and resource ('existing specialist run'). It is distinct from dispatch/run_workflow, which start new runs, though 'specialist run' is not precisely defined.

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

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

The description implies the tool is for continuing an already-started run rather than starting one, but it does not explicitly say when to use this tool versus alternatives like get_run, chat_send, or dispatch. It provides backend-specific context but no direct usage guidance or exclusions.

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

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

No annotations are provided, so the description carries the behavioral burden. 'Fetch' clearly signals a read-only operation and names the returned content, but it does not disclose response shape, error behavior, or whether output is truncated.

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, action-first, with no filler. Every word contributes to the tool's purpose and scope.

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

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

For a one-parameter read tool, the description is nearly sufficient: it identifies what is fetched and how to address the target. It only lacks a pointer to list_runs for discovering run ids and a brief note on expected output 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?

Schema description coverage is 0%, and the description only restates that lookup happens 'by run id.' It adds little beyond the run_id property name and does not explain the format, source, or how to obtain a valid run id.

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 ('Fetch'), a clear resource ('status and output for a dispatch or workflow step'), and an identifier ('run id'). This distinguishes it from list_runs (listing runs) and dispatch/run_workflow (creating runs).

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 use when a run_id is known and status/output is needed, but it does not explicitly mention alternatives or when-not conditions. The contrast with list_runs is natural but left for the agent to infer.

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 key behavioral traits: it does not start a process, it defaults to a specific URL, and it rejects non-loopback URLs. This covers the main safety-relevant behaviors for a probe tool, though it does not describe the exact response or failure modes.

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

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

Two short sentences with no filler. The default URL is front-loaded, the non-start behavior is stated directly, and the loopback restriction is clear. Every sentence earns its place.

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

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

For a single-parameter, no-output-schema probe tool, the description provides the essential invocation context: target, default, side-effect absence, and URL restriction. It is slightly incomplete in not mentioning what a successful probe returns or how failures surface, but for a simple status probe this is a minor 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?

The schema already documents base_url and its loopback requirement with 100% coverage, so the baseline is 3. The description adds value by specifying the actual default URL (http://127.0.0.1:8010/v1) and emphasizing that non-loopback URLs are rejected, reinforcing the schema constraint with practical 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?

The description states a specific action ('Probe') and resource ('loopback late-infer'), and explicitly distinguishes itself from process-starting tools with 'Does not start a process.' Combined with the tool name late_infer_status, an agent can clearly identify this as a status-check operation rather than a lifecycle 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?

The description gives useful context: it is a probe, does not start a process, and only accepts loopback URLs. However, it does not explicitly say when to prefer this over sibling status tools (e.g., llamacpp_status, ollama_status, vllm_status) or mention typical usage such as checking readiness before using start_late_infer. The usage context is implied rather than stated.

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?

Even though no annotations are present, the description discloses that the tool re-reads .env and GUI secrets on each call, so newly added keys take effect without restarting Cursor. It also surfaces important operational constraints: local Cursor agents only write inside allowed directories and cloud Cursor agents cannot reach localhost late-infer. This goes well beyond a bare 'list' description.

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 dense but front-loaded with the resource list, then the when-to-use directive, then behavior and constraints. No sentence is filler; the parentheticals add useful specificity rather than wordiness. It remains readable despite its length.

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 and no annotations, the description must carry the entire load, and it covers purpose, usage timing, internal behavior, and access limitations. It even tells the agent how to react to the cloud/localhost limitation. Nothing essential for tool selection and invocation is missing.

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

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

There are zero parameters, so the schema carries no semantic burden. The description compensates by specifying exactly what categories of information are returned. Baseline 4 applies and it fully satisfies it.

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 opens with the verb 'List' and names an explicit set of resources: specialist agents, backends, workflows, write-allowlist directories, default cwd, and local-runtime status. This clearly distinguishes it from sibling listing tools like list_allowed_dirs and list_runs. It is unambiguous about what the tool does.

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 explicitly instructs 'Call this before dispatching work so you pick a ready backend', giving a clear trigger condition. It also provides routing guidance for cloud Cursor agents by noting to use local-and-cloud or cloud-with-local-draft workflows. It does not name alternatives explicitly, but the context makes the intended use 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?

There are no annotations, so the description must carry behavioral disclosure. It reveals non-obvious behavior (default cwd included; workspace granted by default until more directories are added), and the verb 'List' signals a read-only operation. It doesn't explicitly say 'no side effects,' but nothing suggests mutation.

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 tightly written sentences: the first front-loads the core action and resource, the second adds the key default-state behavior. No filler or redundancy.

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

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

For a parameterless read-only listing tool, the description covers what the result includes and the default grant behavior. It doesn't specify the output format, but with no output schema and a simple list, this is a minor 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?

The tool takes zero parameters, so the baseline is 4. The description adds context about what will be listed, which is all that parameter semantics could require.

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 opens with the specific verb 'List' and a precise resource: directories local Cursor agents may write to, plus the default cwd. This clearly distinguishes it from mutation siblings like add_allowed_dir and remove_allowed_dir.

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 provides useful context ('The workspace is granted by default until you add more') and implies the list operation is how to inspect the current grant. It doesn't explicitly name alternatives or when-not-to-use conditions, so it stops short of a 5.

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

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

With no annotations, the description carries the transparency burden. 'Summarize' signals a non-mutating operation, and the fallback ('CPU if none') plus output fields such as primaryBackend and vendor Docker images disclose key behavior. It does not discuss performance, privileges, or exact return structure, but those are less critical for a zero-parameter read-only listing 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?

One sentence front-loads the action and scope, then packs the relevant output details without filler. No wasted clauses.

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 zero-parameter tool with no output schema, the description names the reported fields (VRAM, primaryBackend, Docker images) and the fallback case. It is complete enough for an agent to invoke and interpret the result, though it does not define primaryBackend or the exact response shape.

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 no parameters, so there is no parameter semantics burden; the description adds the expected output context. Baseline of 4 is appropriate.

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

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

States a specific verb ('summarize'), a defined resource ('discrete GPUs'), and a use context ('local model serving'); enumerates vendor scope and return fields, so it is clearly distinguishable from sibling tools, none of which list hardware.

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 'for local model serving' establishes when the tool is relevant, and the focus on GPUs plus CPU fallback makes its role clear among model-serving siblings. It does not explicitly rule out alternatives or name a sibling, so it stops short of a 5.

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

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

With no annotations provided, the description carries the full burden of behavioral disclosure, and it does so thoroughly. It reveals fallback behavior ('well-known... ids; Hub API rows merge on top when reachable'), authentication effects ('HF_TOKEN from Settings is used... so gated listings appear'), and non-destructive scope ('Does not download'). It also discloses row content such as estimated VRAM at max 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 information-dense and front-loaded with the core purpose, followed by important behavioral caveats. Most sentences earn their place, but the final sentence about 'pull_late_infer / delete_late_infer still wait for Approve' is tangential to this listing tool and slightly dilutes focus.

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

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

Despite having no output schema, the description explains key return content ('Each row includes estimated VRAM at max usage'), data source behavior, and authentication. It does not fully describe the output field set or potential limitations, but for a listing tool with one optional parameter it is reasonably 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?

The only parameter, q, is already fully described in the input schema with an example and empty-value behavior. The description merely restates 'Optional query (Gemma, Qwen, …),' adding no new semantic detail beyond the schema, so the baseline score of 3 applies.

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

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

The description opens with a specific verb and resource: 'List Hugging Face Instruct/chat safetensors for Late infer on your computer.' It distinguishes this tool from local-model or download tools by explicitly stating 'No filesystem path' and 'Does not download,' and it references the GUI catalog for recognizability.

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

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

The description gives clear context for when to use the tool: to search the Hugging Face catalog for Late-infer models, optionally filtered by a query like Gemma or Qwen. It provides negative guidance with 'No filesystem path' and 'Does not download,' which helps separate it from local/file-based alternatives, though it does not explicitly name sibling tools such as list_local_models.

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

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

With no annotations provided, the description carries the full transparency burden. It discloses a surprising behavioral scope by noting that the tool also returns every running loopback vLLM instance, and it specifies useful output facets such as GPU fit flags, newest Hub id, and the allowlisted directory. It does not explicitly state 'read-only,' but the list-style content and zero-parameter signature make that inference strong.

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 dense but front-loaded: it opens with the catalog scope, then efficiently appends the relevant filtering and output details. There is little wasted wording, though the long colon-separated clause sequence is slightly run-on and would be clearer as a short bulleted breakdown.

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 zero-parameter listing tool, the description covers the important content areas and the surprising inclusion of running vLLM instances, so an agent has enough information to select and invoke it correctly. It does not specify the exact return structure or how the model list and instance list are combined, and there is no output schema to fill that 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?

The tool has zero parameters and the schema already provides complete coverage, so there is no parameter-semantic burden for the description to carry. The baseline score for a no-parameter tool 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 a specific resource, the full curated catalog of local vLLM models, and explicitly contrasts it with 'a short slice,' distinguishing it from recommendation-style siblings. It also states the key discriminating contents: fit flags, Hub id resolution, allowlisted directory, and running vLLM instances. This makes the tool's purpose unmistakable.

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

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

The phrase 'full catalog, not a short slice' implies the tool should be used when an exhaustive list is needed rather than a targeted recommendation, which gestures at alternatives like recommend_local_models. However, it never names an alternative or gives an explicit when-to-use/when-not-to-use rule, so the guidance remains implied.

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

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

With no annotations, the description carries the full burden. It communicates that the operation is a read-only listing and provides order ('newest first') and scope ('recent') behavior, but it does not disclose pagination, default limit behavior, or whether all run statuses are included. It is adequate but not rich.

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

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

Eight-word sentence with a strong front-loaded verb and no filler. 'Recent' and 'newest first' add meaning without redundancy; 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?

The tool is simple (one optional parameter, no output schema), so the core purpose and order are present. However, there is no annotation coverage, no guidance on the 'recent' window or default limit, and no sibling differentiation, leaving an agent to infer several invocation 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?

Schema description coverage is 0% and the description never mentions the single 'limit' parameter. The property name and min/max constraints give basic semantics, but no prose explains how the limit is applied (e.g., number of runs returned or default when omitted), so the description fails to compensate for the schema gap.

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

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

The description names the operation ('List') and the resource ('orchestrated runs') and adds a sort order. This is specific enough to distinguish from get_run (single run) and run_workflow/follow_up (run creation/continuation), so it is not a bare restatement.

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 does not explicitly state when to prefer this tool over siblings such as get_run, nor what to do if a specific run or a filtered set is needed. The intended use (viewing recent orchestrated runs) is only implied by the phrasing, and no exclusions or alternatives are given.

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 and does it well: it states this is a probe (not a download or process start) and that non-loopback URLs are rejected. It does not mention the response shape or what happens when the server is unreachable, but the disclosed restrictions and non-mutating scope are solid.

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

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

Three short sentences with no filler. The main action and resource are front-loaded, followed by necessary exclusions and constraints. Every sentence earns its place.

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

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

For a single-optional-parameter status probe with low complexity, the description is largely complete: it covers what the tool does, what it does not do, and URL restrictions. The main gap is that no output schema exists and the description does not state what the probe returns, but the tool name and 'status' context mitigate this.

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

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

Schema description coverage is 100%, and the schema already explains the base_url format and loopback requirement, so the baseline of 3 applies. The description adds marginal value by naming the default value (http://127.0.0.1:8080/v1), but the parameter semantics are primarily handled by 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 states a specific verb ('Probe') and resource ('loopback llama.cpp llama-server OpenAI API') with an explicit default URL. The negative clauses ('Does not download GGUF files or start a process') clearly distinguish it from download/start sibling tools, and naming llama.cpp separates it from vllm_status and ollama_status.

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

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

The description gives clear context for when this tool applies: probing a local llama.cpp server, and it explicitly excludes downloading GGUF files or starting a process. It does not name alternative sibling tools directly, but the exclusions make the selection boundary unambiguous for an 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?

With no annotations, the description carries the behavioral disclosure burden and does it well: it states the tool only talks to a loopback daemon, lists tags when running, does not install Ollama, and rejects non-loopback URLs. It does not describe failure behavior when the daemon is down, but the main side-effect and safety aspects are covered.

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

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

Four short sentences, each earning its place. The primary purpose and default endpoint are front-loaded, followed by key constraints and exclusions. No fluff or repetition of schema content.

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

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

For a simple probe tool with no output schema, the description covers the essential facts: target daemon, default URL, what it returns (tags), and key limitations. It could mention the behavior when the daemon is not running, but the description is sufficient for an agent to invoke it correctly in most cases.

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 schema already describes the base_url parameter. The description adds value by specifying the default URL (http://127.0.0.1:11434) and reinforcing the loopback-only restriction, going beyond the schema's basic parameter description.

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

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

The description states a specific verb ('Probe') and a specific resource ('loopback Ollama daemon'), with the default endpoint included. This clearly distinguishes it from sibling status tools like vllm_status and llamacpp_status by naming Ollama as the target.

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 clearly implies when to use the tool: when checking an Ollama daemon on loopback. It also gives explicit exclusions: it does not install Ollama and rejects non-loopback URLs. It does not explicitly name sibling alternatives, but the context is strong enough for an agent to select it appropriately.

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 and does substantial work. It discloses idle-GPU detection, vendor-specific compilation, the 'Intel is never treated as NVIDIA' safeguard, the Late Approve wait, and the fixed destination with no filesystem-path input. It does not cover failure modes or return behavior, but the key side effects and constraints are clear.

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 three dense sentences with no filler. The main action is front-loaded, followed by decision-relevant constraints, and every clause — from GPU detection to the fixed destination — earns its place.

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

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

For a single-parameter tool with no annotations and no output schema, the description is quite complete: it covers purpose, hardware behavior, concurrency, prerequisites, and path constraints. It stops short of perfection by not stating what the call returns or what happens when no idle GPU is available, though these are secondary.

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

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

The input schema already covers the single model parameter at 100%, including an example. The description restates 'Requires a Hub org/model id' but adds no new format, default, or deeper semantics beyond the schema, so it meets the baseline without exceeding it.

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 opens with a specific verb and resource: 'Pull a Hugging Face model snapshot and compile it for late-infer.' It adds clear scope with 'on this computer' and distinguishes itself from sibling tools like download_local_model or start_late_infer by emphasizing compilation and GPU-vendor detection.

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 prerequisites and constraints: 'Requires a Hub org/model id' and 'Extra calls wait for Late Approve.' However, it never names an alternative tool or explicitly states when to use this versus the related siblings, so usage selection is mostly implied rather than direct.

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 discloses that fit flags are computed for local GPUs, explains the three fit categories, notes that newest Hub IDs are marked, and states that nothing is hidden. It intentionally reveals the hardware-dependent filtering behavior, especially the CPU-only fallback.

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, all dense with useful information and zero fluff. The most important point — exhaustive catalog with fit flags — is front-loaded, and the extra details about version selection and accelerator absence are compact.

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

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

Despite having no output schema and no annotations, the description gives enough context for an agent to know what to expect: fit categories, version preference marks, exhaustive coverage, and CPU-only behavior on machines without an accelerator. It could add a sentence about the intended follow-up (e.g., download or start), but it is already quite complete for a zero-parameter read-style tool.

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

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

The tool has zero parameters and an empty input schema, so there is no parameter burden for the description to carry. The baseline for no-parameter tools applies, and the description adds no unnecessary param-related filler.

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 that the tool surfaces every catalog model for local vLLM with hardware-fit flags, which conveys the resource and the kind of recommendation being made. It does not explicitly contrast itself with sibling list_local_models, but the scope ('Every catalog model' and 'fit flags') is sufficiently specific.

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 when selecting models for this computer's GPUs and when the user wants an exhaustive, unfiltered view of the catalog. However, it does not explicitly say when not to use it or mention alternatives like list_local_models for installed models.

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 responsibility. It discloses the core mutating behavior (revoke) and a meaningful side effect (Local Cursor dispatch fails if cwd loses access). This goes beyond a bare statement of purpose, though it omits details like behavior for non-existent paths or idempotency.

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

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

Two short sentences with no fluff. The primary action is front-loaded, and the second sentence adds a genuinely useful consequence rather than repeating the tool name or 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?

For a simple one-parameter revocation tool, the description covers what the tool does and an important operational consequence. No output schema exists, but for a mutating command this is acceptable; still, a brief note on error behavior would make it fully 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?

The input schema already fully describes the single parameter with 100% coverage, so the description does not need to do much. It adds mild contextual framing by calling it a 'write directory,' but no new parameter-level details.

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

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

The description uses a precise verb/resource pair ('Revoke a previously granted write directory') and clearly differentiates from siblings like add_allowed_dir and list_allowed_dirs by focusing on removal. The consequence clause reinforces what the tool actually does.

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 'previously granted' makes the usage context clear, and the warning about Local Cursor dispatch failing provides practical guidance about consequences. However, it does not explicitly name alternatives or state 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 the full burden of behavioral disclosure. It clearly states the config file mutation, the selective shutdown, and two important non-effects: other models stay up and weights remain on disk.

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 concise sentences each add value: the core action, the scope, and the clarifying non-effect. The description is front-loaded and contains no redundant phrasing.

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 annotations and no output schema, the description covers the essential invocation semantics and side effects well. Minor gaps remain around error conditions, whether a restart is possible after removal, and which parameter is needed when both are optional.

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

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

The input schema already documents both parameters with 100% coverage, so the baseline applies. The description loosely maps to model_id/backend_id but adds no extra detail about parameter precedence, combinations, or formats beyond what the schema provides.

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

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

The description uses specific action verbs ('stop' and 'unregister') with clear resources (vLLM instance, backend, specialist, agents.config.yaml). It also distinguishes itself from sibling operations by explicitly stating that downloaded weights are not 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?

The description clearly scopes the operation: it affects exactly one instance, leaves other running models up, and does not remove weights. It does not explicitly name alternative tools such as stop_vllm or delete_local_model, so it stops short of full alternative routing.

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 disclosure burden, and it does so substantively: it reveals that sequential steps see prior output, parallel recipes collect both results, local writes require an allowed cwd, and cloud agents never call localhost vLLM. It does not disclose the return model (e.g., whether a run ID is returned synchronously or how to poll), which keeps this from 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?

The description is compact and front-loaded: purpose first, then workflow options, then behavioral constraints. Every sentence carries useful information with no filler or repetition of schema details, achieving high information density in under 100 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?

This is a complex multi-agent orchestration tool with 8 parameters and no output schema, yet the description says nothing about the return value, run lifecycle, or how to retrieve results. Sibling tools like get_run and list_runs hint at a run model, but the description itself leaves an agent without enough information to know what happens after invocation.

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

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

Schema description coverage is only 38%, so the description needed to compensate for undocumented parameters. It adds real value for 'workflow' by listing built-in option names and for 'cwd' by noting the allowed-directory requirement. However, branch, pr_url, repo_url, and extra_context remain unexplained in both schema and description, 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?

The description opens with a specific verb+resource: 'Run a named multi-agent pipeline.' It then enumerates four concrete built-in workflows (ship-feature, troubleshoot-pr, local-and-cloud, cloud-with-local-draft), making the tool's scope unmistakable and clearly distinguishing it from simpler sibling tools like dispatch or vllm_status.

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

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

The description gives clear contextual guidance by listing the built-in recipes and explaining sequential vs. parallel execution behavior. It does not explicitly contrast run_workflow with alternatives like dispatch or chat_send, so exclusions and when-not-to-use guidance are missing, but an agent can infer the intended use case from the named pipeline framing.

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 bind address restrictions, binary source, first-start loading behavior, and the non-auto-run approval wait. This gives an agent critical behavioral expectations beyond a bare 'start' verb, though it stops short of full lifecycle or status details.

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 compact sentences, front-loaded with the action and address constraint. Each subsequent clause adds a necessary caveat (binary source, first-start behavior, approval wait) without filler.

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

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

For a start command with no output schema and no annotations, the description covers endpoint, binary resolution, first-run model loading, and the non-auto-run approval behavior. It could mention status verification or what 'Late Approve' entails, but the essentials are present.

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 both parameters with descriptions (100% coverage), so the baseline of 3 applies. The main description ties model loading to Hugging Face safetensors, but adds limited parameter-level meaning beyond what the schema already provides.

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

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

States the action 'Start late-infer' plus resource/scope ('on this computer') and distinct endpoint constraint ('OpenAI /v1 on 127.0.0.1:8010 only'). This separates it from sibling start_* tools by naming the exact server and bind address, so an agent can identify what it does.

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 context: local-only launch, never LAN/0.0.0.0, and distinguishes first start from extra calls ('Extra calls wait for Late Approve — this is not auto-run'). It does not explicitly name alternatives like start_llamacpp/start_vllm, but the local endpoint and late-infer naming provide clear 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?

With no annotations, the description carries the full behavioral burden. It discloses meaningful traits: the server binds only to 127.0.0.1:8080, and extra calls wait for 'Late Approve'. However, the 'Late Approve' mechanism is left cryptic, and there is no mention of whether the call blocks, returns a status, or handles already-running servers.

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

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

Two sentences, front-loaded with the action and constraints, followed by the notable queuing behavior. No filler or redundancy, though the unexplained 'Late Approve' term slightly reduces 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?

The tool is simple (one required parameter), and the description covers the core constraints: localhost-only binding and the approval-wait behavior. Yet it leaves ambiguities such as what 'Late Approve' means, whether the call returns before the server is ready, and how errors like port conflicts are handled. Given no annotations and no output schema, a bit more context would improve 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 100%, so the schema already documents model_path as an absolute path to a .gguf file. The description's mention of 'absolute .gguf path' adds no meaningful semantic value beyond the schema, so the baseline of 3 applies.

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

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

The description uses a specific verb ('Start'), names the resource ('llama-server'), and adds location/port constraints ('127.0.0.1:8080 only') plus the required input type ('absolute .gguf path'). This clearly distinguishes it from sibling tools like start_ollama, start_vllm, and start_late_infer.

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 context is clear: use this to start llama-server locally with a .gguf file. However, it does not explicitly state when to prefer this over sibling start_* tools, mention alternatives, or explain when not to use it. Usage guidance is therefore implied rather than explicit.

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

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

With no annotations, the description carries the full burden of behavioral disclosure. It reveals the specific bind address, a queueing/approval behavior ('Extra calls wait for Late Approve'), and a limitation (no model pulls). It does not state what happens if Ollama is already running, but for a simple start command this is a solid disclosure.

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

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

Three short sentences, each carrying distinct information: purpose and scope, concurrency behavior, and a key exclusion. There is no filler, repetition, or unnecessary detail, and the primary action is front-loaded.

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

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

For a no-parameter, no-output-schema tool with no annotations, the description covers the essential behavior, network scope, and a critical limitation. It does not mention how to confirm the startup result, but an agent could combine this with status/lifecycle siblings like ollama_status. This is nearly complete for the tool's complexity.

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 properties and 100% coverage, so there are no parameter semantics to document. The baseline for a no-parameter tool is 4, and the description appropriately focuses on behavior rather than parameters.

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

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

The description states a specific verb and resource: 'Start Ollama serve' on this computer, bound to 127.0.0.1:11434. This clearly distinguishes it from sibling tools like start_llamacpp and start_vllm by naming the exact service and scope. The 'Does not pull models' line further separates it from model-management siblings.

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 clear context by restricting the tool to a local 127.0.0.1:11434 startup and explicitly stating it does not pull models, which rules out using it for model acquisition. However, it does not directly name alternatives such as start_llamacpp or download_local_model, leaving some 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 fully carries the burden of behavioral disclosure. It covers binding restrictions, container isolation, tensor-parallel scaling, health checking, backend/specialist upsert, dummy Bearer storage ('never copy a key from vLLM'), and the fact that cloud agents cannot reach the server. This is exceptionally detailed for a tool without annotations.

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

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

The description is long yet dense; every sentence introduces a distinct fact (binding, containerization, GPU scaling, replace semantics, intel-xpu special case, health wait, secrets handling). The most important scoping constraint ('bound to 127.0.0.1 only') is front-loaded at the very beginning.

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 tool with no output schema or annotations, the description covers prerequisites, side effects, platform differences, security, and idempotency. It also describes the completion condition (waits until GET /v1/models is healthy) and the state changes performed, making the tool fully actionable.

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 descriptions cover 67% of parameters, and the description adds meaning beyond them—e.g., clarifying the default tensor-parallel behavior, the intel-xpu container selection, the backend id derivation (vllm-<slug>), and the port range. It does not explain timeout_ms or quantization, but the schema constraints/enums partially cover those.

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

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

The description states a specific verb ('Launch'), a resource ('local OpenAI-compatible server'), and adds precise constraints (bound to 127.0.0.1 only, port 8000–8099, per-model Docker container). It clearly differentiates from sibling tools like stop_vllm, remove_vllm, and vllm_status by focusing on starting a vLLM server.

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 a prerequisite ('Model must already be downloaded'), explains when to use use_all_gpus=false, and gives platform-specific behavior on intel-xpu. It also clarifies the replace semantics relative to other running containers. However, it never explicitly names sibling alternatives such as download_local_model or vllm_status, leaving some comparison 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 present, so the description carries the behavioral disclosure burden. It discloses a non-obvious limitation: only owned PIDs are stopped, and externally started late-infer processes are left running. It does not mention side effects or idempotency, but the ownership caveat is the most important behavioral trait for this 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?

Two short sentences front-load the main action and scope. The phrase 'a late-infer Late started' is awkward and somewhat confusing, which prevents a perfect score.

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 stop tool with no output schema and no annotations, the description provides the essential operational context: what is stopped, which processes qualify, and which are explicitly not touched. It lacks detail on return behavior or error cases, but the low complexity makes this acceptable.

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

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

The tool has zero parameters and the schema has no properties, so the baseline is 4. There are no parameter details needed, and the description does not attempt to invent any.

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

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

The description states a specific action ('Stop') and resource ('the late-infer process this orchestrator started'), with an explicit scope restriction ('owned pid only'). This clearly distinguishes it from related tools like start_late_infer and delete_late_infer.

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 ownership condition implies when it should be used: only for late-infer processes started by this orchestrator. It explicitly says it does not kill a late-infer process started elsewhere, providing a meaningful exclusion even though sibling alternatives are not named by 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?

There are no annotations, so the description must carry behavioral disclosure. It usefully reveals a safety constraint: it only acts on owned pids, not arbitrary llama-server processes. However, it does not disclose whether the stop is graceful, what happens if no owned process is running, or whether the call waits for termination.

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

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

The description is a single, front-loaded sentence. Every clause adds value: the action, the target process, and the ownership restriction. There is no wasted or redundant wording.

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 zero-parameter, no-output-schema tool, this description is nearly complete. It names the target and the key behavioral boundary. It could add a note about idempotency or behavior when no owned process exists, but the low complexity makes the description 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?

The tool has zero parameters, so parameter documentation is not needed. The description correctly identifies the implicit target (the orchestrator-owned llama-server process), which is sufficient given the empty input 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 uses a specific verb, 'Stop', names the exact resource ('llama-server process'), and adds the scope qualifier 'this orchestrator started (owned pid only)'. This clearly distinguishes it from sibling stop tools like stop_vllm and stop_ollama without needing to inspect schemas.

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

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

The phrase 'this orchestrator started (owned pid only)' provides an explicit usage boundary: only stop llama-server processes owned by this orchestrator. It implies the tool should not be used for external or unrelated processes, though it does not explicitly name alternatives such as stop_vllm for other engines.

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

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

With no annotations provided, the description carries the full burden of disclosing behavior. It clearly conveys that this is a destructive action ('Stop') and adds the important safety constraint that only the orchestrator-owned PID is affected. It could mention what happens if the process is already stopped or whether shutdown is graceful, but the core behavioral risk is well covered.

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

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

A single tight sentence delivers the action, target, and ownership constraint with no wasted words. The most important qualifier is placed directly after the verb phrase, so an agent scanning quickly gets the essential meaning immediately.

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

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

For a zero-parameter, no-output-schema tool, the description is complete enough. It states what will be stopped and under what condition, and the owning-orchestrator clarification resolves the main ambiguity an agent could face when selecting this tool among siblings.

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

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

The tool has zero parameters and schema coverage is 100%, so there is no parameter documentation burden for the description to carry. Per calibration, a zero-parameter tool receives 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 uses a specific verb ('Stop'), a clear resource ('the Ollama process'), and an important scope qualifier ('this orchestrator started (owned pid only)'). This distinguishes the tool from monitoring siblings like ollama_status and start_ollama, and prevents confusion about what exactly gets stopped.

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 clearly states that this tool only applies to the orchestrator-owned Ollama process, giving an implicit when-to-use and when-not-to-use boundary. It does not name alternative tools, but no close alternative for stopping Ollama exists among the siblings, so the guidance is reasonably complete.

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

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

With no annotations provided, the description carries the burden of behavioral disclosure. It explains conditional failure ('the call fails unless all=true'), scopes the operation to orchestrator-managed instances, and clarifies the leftover orch-vllm edge case. It does not detail the exact stopping mechanism or what happens if the target is not found, but the core behavior is transparent.

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

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

The description is four sentences, front-loaded with the primary action and scope, and every sentence adds unique value. There is no repetition or filler.

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

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

Given no annotations or output schema, the description covers the main invocation logic, key failure mode, and scope exclusions. Minor ambiguities remain, such as behavior when exactly one instance is running with no id set, but the overall guidance is sufficient for correct use in most cases.

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 documents all three parameters, but the description adds valuable semantics: pass model_id or backend_id to leave other running models up, and all=true bypasses the failure when no id is set. This goes beyond the simple property descriptions in 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 action ('Stop one orchestrator-managed vLLM instance') and identifies the resource type ('container or host process group'). It also explicitly excludes unrelated Docker containers, which differentiates its scope from broader stop operations.

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 concrete guidance on when to pass model_id or backend_id, and when all=true is required. It also includes an important exclusion ('Does not stop unrelated Docker containers'). However, it does not explicitly discuss alternatives like remove_vllm or describe when a user should prefer a different 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 behavioral burden. It discloses the output scope and the local Intel Docker image nuance, and the status framing implies a read-only operation. However, it does not explicitly state that no state changes occur, nor any other behavioral traits such as permissions or latency.

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 well-structured sentence delivers the full scope of the tool. The core subject is front-loaded, and the parenthetical detail adds meaningful specificity without 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?

For a zero-parameter status/read tool, the description adequately conveys what information the agent will receive. A formal return schema or exact JSON shape would improve completeness, but the description gives enough detail to set expectations.

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

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

The tool has zero parameters, so the baseline is 4. The description correctly focuses on the output rather than parameters, and no parameter compensation 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 identifies the resource ('orchestrator-managed vLLM instances') and enumerates the fields returned (image, port, model, backend id, container), plus the additional serving-stack check. Although it lacks an explicit verb like 'list' or 'get', the intent is evident and it is distinguishable from the lifecycle sibling tools such as start_vllm and stop_vllm.

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 is provided about when to use this tool versus alternatives. There is no mention of checking status before starting/stopping instances or comparing against list_hardware/list_local_models. Usage context is only implied by the tool name and content.

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