whatbox-mcp

Server Quality Checklist

Profile completionA complete profile improves this server's visibility in search results.

Latest release: v0.10.0
Disambiguation3/5
Several status/inspection tools have overlapping scopes (e.g., whatbox_services_status, whatbox_operational_snapshot, whatbox_configuration_status, whatbox_website_diagnostics) which could cause an agent to pick the wrong one. Descriptions help but boundaries are not crisp, especially between configuration_status and configuration_review.
Naming Consistency2/5
Most tools use a whatbox_ prefix but a few do not (server_info, list_capabilities), and naming patterns vary between verb-first (whatbox_list_directory) and noun-first (whatbox_website_readiness, whatbox_services_status). This mixed convention makes the API harder to predict.
Tool Count2/5
With 30 tools, the server is well beyond the typical 3-15 range. While the domain covers multiple subsystems, the sheer number creates navigation overhead and suggests several status/read-only tools could be consolidated.
Completeness4/5
The suite covers core file operations, quarantine, torrents, website deployment, services, backup, and connection checks. Missing a direct file deletion (only quarantine/purge) and some status tools are redundant, but the main lifecycle workflows are well represented.
Average 4.1/5 across 30 of 30 tools scored. Lowest: 3.5/5.
See the Tool Scores section below for per-tool breakdowns.
- No community issues in the last 6 months
- 11 commits in the last 12 weeks
- No stable releases found
- No critical vulnerability alerts
- No high-severity vulnerability alerts
- No code scanning findings
- CI is passing
This repository is licensed under MIT License.
This repository includes a README.md file.
No tool usage detected in the last 30 days. Usage tracking helps demonstrate server value.
Tip: use the "Try in Browser" feature on the server page to seed initial usage.
Add a glama.json file to provide metadata about your server.
If you are the author, simply .
If the server belongs to an organization, first add glama.json to the root of your repository:
```
{
  "$schema": "https://glama.ai/mcp/schemas/server.json",
  "maintainers": [
    "your-github-username"
  ]
}
```
Then . Browse examples.
Add related servers to improve discoverability.

How to sync the server with GitHub?

Servers are automatically synced at least once per day, but you can also sync manually at any time to instantly update the server profile.

To manually sync the server, click the "Sync Server" button in the MCP server admin interface.

How is the quality score calculated?

The overall quality score combines two components: Tool Definition Quality (70%) and Server Coherence (30%).

Tool Definition Quality measures how well each tool describes itself to AI agents. Every tool is scored 1–5 across six dimensions: Purpose Clarity (25%), Usage Guidelines (20%), Behavioral Transparency (20%), Parameter Semantics (15%), Conciseness & Structure (10%), and Contextual Completeness (10%). The server-level definition quality score is calculated as 60% mean TDQS + 40% minimum TDQS, so a single poorly described tool pulls the score down.

Server Coherence evaluates how well the tools work together as a set, scoring four dimensions equally: Disambiguation (can agents tell tools apart?), Naming Consistency, Tool Count Appropriateness, and Completeness (are there gaps in the tool surface?).

Tiers are derived from the overall score: A (≥3.5), B (≥3.0), C (≥2.0), D (≥1.0), F (<1.0). B and above is considered passing.

Tool Scores

Behavior3/5
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
Annotations already declare readOnlyHint=true, destructiveHint=false, and idempotentHint=true. The description adds the human decision-making context, which is useful but doesn't disclose any additional behavioral traits such as output format or filtering capabilities. No contradiction with annotations.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Conciseness5/5
Is the description appropriately sized, front-loaded, and free of redundancy?
The description is a single, compact sentence that front-loads the action and purpose without any unnecessary words or repetition of annotations.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Completeness2/5
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
The tool is simple, but the complete absence of parameter documentation (rootIndex) leaves a significant gap. There is no output schema, and the description doesn't clarify the return format or what 'items' refers to. The purpose is clear, but operational details are insufficient.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Parameters1/5
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
The schema provides no description for rootIndex (0% coverage), and the description doesn't mention it at all. The agent is left without any explanation of what rootIndex controls, making correct invocation guesswork.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Purpose5/5
Does the description clearly state what the tool does and how it differs from similar tools?
The description clearly states the action (list), the resource (quarantine directory), and the purpose (so a human can choose to restore or purge). It distinguishes itself from siblings like whatbox_purge_quarantine and whatbox_move_path.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Usage Guidelines4/5
Does the description explain when to use this tool, when not to, or what alternatives exist?
The description implies the use case: listing quarantine items before a human decides to restore or purge. It doesn't explicitly name alternatives or exclusion criteria, but the context is clear enough that an agent would know when to invoke this tool.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Behavior3/5
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
The description discloses the SSH loopback tunnel transport and bounded scope, adding context beyond annotations. It is consistent with readOnlyHint and idempotentHint, but does not elaborate on failure modes, result format, or tunnel dependencies.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Conciseness5/5
Is the description appropriately sized, front-loaded, and free of redundancy?
The description is two concise sentences, front-loading the action, scope, and mechanism. Every word serves a purpose, with no redundant phrases.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Completeness4/5
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
Given no output schema and no parameters, the description is reasonably complete with purpose, field list, transport, and read-only nature. However, 'bounded' could be more explicit about result limits or pagination.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Parameters4/5
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
The tool has zero parameters, so the schema is trivially complete. The description adds meaning by enumerating the returned fields, which is the only semantic value beyond the empty schema.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Purpose4/5
Does the description clearly state what the tool does and how it differs from similar tools?
The description clearly states it reports torrent status with a specific field set (name, state, progress, ratio, label, totals) via SSH loopback RPC. It is distinct from sibling whatbox_torrent_clients_status, but does not explicitly name alternatives, so it falls short of a 5.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Usage Guidelines2/5
Does the description explain when to use this tool, when not to, or what alternatives exist?
No guidance is provided on when to use this tool versus alternatives like whatbox_torrent_clients_status. The description explains what it does but not the context or exclusion criteria, leaving the agent to infer usage.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Behavior4/5
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
Annotations already declare readOnlyHint=true, idempotentHint=true, and destructiveHint=false, so the safety profile is covered. The description adds valuable behavioral context: "Absolute paths and path escapes are rejected," which informs the agent about input validation behavior beyond the annotations. It does not describe response details, but the output schema covers that.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Conciseness5/5
Is the description appropriately sized, front-loaded, and free of redundancy?
The description is two succinct sentences: the first states the action and scope, the second states a critical constraint. Both sentences carry necessary information with no filler, and the most important purpose is front-loaded.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Completeness2/5
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
For a tool with three optional parameters and no schema descriptions, the description is too sparse. It fails to explain rootIndex, which is essential for directing the tool to the correct allowed root. The security constraint is helpful, but without understanding the root selection mechanism and the expected relative path format, the agent cannot reliably invoke the tool.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Parameters2/5
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
Schema description coverage is 0%, so the description must explain parameter semantics. It only hints that paths are relative (by rejecting absolute paths) but does not explain rootIndex (what a root index refers to, how to select among multiple roots) or limit. The agent is left to guess the meaning of rootIndex and the expected format of relativePath, making the parameter semantics incomplete.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Purpose5/5
Does the description clearly state what the tool does and how it differs from similar tools?
The description starts with a specific verb+resource: "List a directory below an explicitly allowed Whatbox storage root." It clearly distinguishes this from sibling listing tools like whatbox_list_quarantine by specifying the allowed root scope and the security constraint, making it unambiguous.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Usage Guidelines3/5
Does the description explain when to use this tool, when not to, or what alternatives exist?
The description implies appropriate usage: you use this tool to list directories within an explicitly allowed storage root, and it warns that absolute paths are rejected. However, it does not explicitly compare with alternatives or state when not to use it (e.g., when dealing with quarantine). The guidance is more implied than explicit.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Behavior4/5
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
Annotations already declare the tool as read-only, idempotent, and non-destructive, and the description adds a valuable behavioral guarantee by specifying 'non-sensitive metadata'. This clarifies the scope of data returned, going beyond the annotations without contradicting them.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Conciseness5/5
Is the description appropriately sized, front-loaded, and free of redundancy?
The description is a single, front-loaded sentence that immediately communicates the core purpose ('Return...'). It is concise, with no filler or redundant information, and effectively uses every word.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Completeness5/5
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
This is a very simple zero-parameter tool, and the description covers the essential purpose and scope. The rich annotations (readOnly, idempotent, non-destructive) and the presence of an output schema fill in the remaining context, making the description complete for selection and invocation.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Parameters4/5
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
The tool has zero parameters, and the schema coverage is vacuously 100%. With no parameters to explain or clarify, the baseline of 4 is appropriate, and the description correctly avoids adding meaningless parameter information.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Purpose4/5
Does the description clearly state what the tool does and how it differs from similar tools?
The description clearly states the tool's action ('Return') and resource ('metadata about this local Whatbox MCP server'), making its purpose unambiguous. However, it does not explicitly differentiate it from sibling tools such as whatbox_configuration_status or list_capabilities, which could also be used to gather information about the server.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Usage Guidelines2/5
Does the description explain when to use this tool, when not to, or what alternatives exist?
No guidance is provided about when to use this tool versus the many sibling status/info tools. The description simply states what it does without mentioning alternatives, exclusions, or typical use cases, leaving the agent to infer when it is appropriate.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Behavior4/5
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
With no annotations providing safety or side-effect information, the description carries full burden and adds two concrete behavioral details: "Skips symlinks" and "checks local free space first." This goes beyond a generic download description, though it does not mention overwrite behavior or return values.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Conciseness5/5
Is the description appropriately sized, front-loaded, and free of redundancy?
The description is two concise sentences with no filler. The main purpose is stated first, followed by important caveats, making it easy to parse quickly.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Completeness3/5
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
For a tool with no output schema and zero parameter descriptions, the description provides the core purpose and two behavioral traits, but it omits parameter semantics and any guidance on expected results or failure conditions. This makes it minimally viable but not fully complete.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Parameters2/5
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
Schema description coverage is 0%, so the description must explain the parameters. It mentions "remote file or directory" but does not clarify what "remoteRelativePath" is relative to, nor the meaning of "rootIndex." The agent cannot infer parameter semantics from the description.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Purpose5/5
Does the description clearly state what the tool does and how it differs from similar tools?
The description clearly states the action ("Download"), the resource ("a remote file or directory"), and the destination ("configured local download directory"). This distinguishes it from sibling tools like whatbox_upload_path and whatbox_move_path.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Usage Guidelines3/5
Does the description explain when to use this tool, when not to, or what alternatives exist?
The description implies the tool is for downloading remote content to local storage, but it does not explicitly mention when to use it over alternatives or provide any exclusions. The context of siblings makes the use case obvious, but there is no direct guidance.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Behavior4/5
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
The annotations already indicate a mutating, non-destructive operation. The description adds valuable context with 'without overwriting an existing destination' and 'Reversible,' clarifying safety guarantees beyond the boolean hints. It does not mention permissions or failure modes, but the added detail is meaningful.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Conciseness5/5
Is the description appropriately sized, front-loaded, and free of redundancy?
The description is two sentences and front-loads the primary verb and object. The second sentence 'Reversible' is brief but adds a useful behavioral note without waste.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Completeness3/5
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
For a 4-parameter tool with no output schema and no informative annotations, the description provides the core action and constraints but omits details about parameter semantics and return behavior. 'Allowed roots' and 'Reversible' are not elaborated, leaving some ambiguity, but the tool's simplicity keeps it minimally viable.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Parameters2/5
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
With 0% schema description coverage, the description must explain the parameters, but it does not. It mentions 'roots' but does not introduce sourceRootIndex or destinationRootIndex, nor does it clarify that paths are relative strings. The agent is left without guidance on populating the required fields.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Purpose5/5
Does the description clearly state what the tool does and how it differs from similar tools?
The description uses the specific verbs 'Move or rename' and identifies the resource as 'a path between allowed roots,' clearly distinguishing it from sibling tools like upload, download, or quarantine. The title 'Move a Whatbox Path' reinforces the function without ambiguity.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Usage Guidelines3/5
Does the description explain when to use this tool, when not to, or what alternatives exist?
The description implies the tool is for moving or renaming files but does not explicitly state when to use it over alternatives such as whatbox_upload_path or whatbox_download_path. No exclusions or alternative tool references are provided, so usage context is only implied.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Behavior4/5
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
The description adds meaningful behavioral context beyond the annotations: it introduces the concepts of allowlisting, fixed start scripts, bounded signals, and the human approval requirement for stop/restart. These details are not present in the annotations, which only provide boolean hints (readOnlyHint false, destructiveHint false). The description succeeds in disclosing important operational constraints.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Conciseness5/5
Is the description appropriately sized, front-loaded, and free of redundancy?
The description is two concise sentences. The first sentence defines the tool's purpose, and the second adds a critical constraint. There is no redundant information or filler. Every word contributes to the meaning.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Completeness3/5
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
For a tool with no output schema and modest annotations, the description covers essential usage and a key safety condition, but it omits any details about return values, error handling, or side effects. The tool modifies service state, yet the description does not explain what happens after a successful start, whether commands are blocking, or how failures are reported. This leaves gaps for an agent.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Parameters2/5
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
With 0% schema description coverage, the description was expected to compensate for parameter semantics, but it does not explicitly explain the 'service' and 'operation' fields. It vaguely references 'service' via 'allowlisted userland service' and mentions 'stop/restart' in the approval note, but it fails to map directly to the schema parameters or clarify their values. The enums are self-explanatory, but the description adds little value for understanding the parameters.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Purpose5/5
Does the description clearly state what the tool does and how it differs from similar tools?
The description clearly states the tool's function: controlling allowlisted userland services via start scripts and bounded process signals. The title explicitly lists start, stop, and restart, and the schema confirms the operation enum. It is specific and distinguishable from sibling tools like whatbox_services_status (status-only) and whatbox_torrent_control (torrent-specific).
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Usage Guidelines3/5
Does the description explain when to use this tool, when not to, or what alternatives exist?
The description implies when to use the tool (to control a service) and adds a key constraint (human approval for stop/restart), but it does not explicitly mention alternatives or exclusion scenarios. No guidance is given about when to prefer a sibling tool, such as using whatbox_services_status to check current state first.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Behavior3/5
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
Annotations already indicate this is a non-read-only, non-idempotent, non-destructive operation. The description adds 'Reversible' and 'configured client RPC', which provides some extra context but does not go into depth about side effects, errors, or prerequisites. This meets the baseline for adding some value beyond annotations but not rich behavioral disclosure.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Conciseness5/5
Is the description appropriately sized, front-loaded, and free of redundancy?
The description is a single, concise sentence that gets straight to the point. It uses no unnecessary words and is easy to parse.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Completeness3/5
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
Given the tool's low complexity (two parameters, no output schema), the description covers the core action and source, and notes reversibility. However, it omits any explanation of the 'paused' parameter, which is a meaningful gap for an agent trying to invoke the tool correctly. The description is adequate but not fully complete.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Parameters2/5
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
The schema has two parameters (paused, magnetOrUrl) with no descriptions, and schema description coverage is 0%. The description explains the magnetOrUrl parameter by stating it accepts a magnet or HTTP(S) URL, but it does not mention the 'paused' parameter at all. Since the description must compensate for the lack of schema documentation, this partial coverage is insufficient.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Purpose5/5
Does the description clearly state what the tool does and how it differs from similar tools?
The description clearly states the action (add a torrent), the source (bounded magnet or HTTP(S) URL), and the mechanism (configured client RPC). This distinguishes it from sibling tools like whatbox_torrent_remove and whatbox_torrent_control, which serve different purposes.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Usage Guidelines4/5
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: to add a torrent via magnet or HTTP(S) URL. It does not explicitly mention alternatives or exclusions, but the purpose is so specific that the usage context is unambiguous. This aligns with 'clear context, no exclusions' rather than explicit 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.
Behavior4/5
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
Annotations (readOnlyHint=false, destructiveHint=false) do not clearly convey the mutating nature of the operation. The description adds valuable context: atomicity, health-checking, and the requirement for explicit human approval. This goes beyond the structured data and discloses important behavioral traits.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Conciseness5/5
Is the description appropriately sized, front-loaded, and free of redundancy?
The description is two short sentences, front-loaded with the primary action and a key prerequisite. Every word earns its place; no redundant or vague filler.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Completeness3/5
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
The core purpose and a critical behavioral constraint (human approval) are covered. However, with no output schema and incomplete parameter explanations, the agent is left unsure about the meaning of rootIndex and what the tool returns after health-checking. Gaps exist but not fatal for a simple rollback operation.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Parameters2/5
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
Schema description coverage is 0%, so the description must compensate. It indirectly references releaseId via 'existing prior release' but does not mention rootIndex at all. This leaves a required parameter (releaseId) partially explained and an optional parameter (rootIndex) completely undefined.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Purpose5/5
Does the description clearly state what the tool does and how it differs from similar tools?
The description clearly states the action: atomically repoint the current-release pointer to an existing prior release and health-check it. It uses a specific verb ('repoint') and resource, distinguishing it from sibling tools like whatbox_website_deploy_execute (which promotes a new release) and whatbox_website_readiness (which checks status).
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Usage Guidelines3/5
Does the description explain when to use this tool, when not to, or what alternatives exist?
The description implies when to use this tool (when rolling back to a previous release) and sets a prerequisite (explicit human approval), but it does not explicitly mention alternatives or exclusion criteria. No direct comparison to sibling tools is provided.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Behavior4/5
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
The description adds behavioral context beyond annotations: 'without overwriting' reinforces non-destructiveness, 'Reversible' indicates undo capability, and 'checks remote free space first' reveals a safeguard. These details are not in the annotations and help the agent understand side effects and preconditions.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Conciseness5/5
Is the description appropriately sized, front-loaded, and free of redundancy?
The description is a single sentence that front-loads the primary purpose and includes critical constraints. Every word adds value, with no redundancy or fluff.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Completeness2/5
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
The tool has no output schema and minimal annotations. The description covers safety precautions but omits return values, error conditions, path interpretation, and what happens on success or failure. Given the tool's complexity (3 parameters, upload semantics), this is insufficient for an agent to invoke it reliably.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Parameters2/5
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
With schema description coverage at 0%, the description should explain parameters. It references 'local file or directory' and 'allowed remote root' but does not clarify the meaning of rootIndex or remoteRelativePath, nor provide format or examples. This is inadequate compensation for the missing schema descriptions.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Purpose5/5
Does the description clearly state what the tool does and how it differs from similar tools?
The description clearly states the action ('Upload'), the resource ('local file or directory'), and the destination ('allowed remote root'). It also distinguishes this tool from siblings like download and move by specifying upload semantics and the 'without overwriting' constraint.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Usage Guidelines4/5
Does the description explain when to use this tool, when not to, or what alternatives exist?
The description provides clear context: it is for uploading allowlisted local paths to an allowed remote root, with a non-destructive intent. However, it does not explicitly compare against alternative tools or state when not to use it, so it falls 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.
Behavior4/5
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
Annotations already declare destructiveHint=true, but the description adds beyond that by stating the operation is irreversible and requires its own explicit human approval. This is valuable context for an agent deciding to invoke the tool.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Conciseness5/5
Is the description appropriately sized, front-loaded, and free of redundancy?
Exactly two sentences, front-loaded with the action ('Permanently delete'), no filler words. Every phrase earns its place: the target, the irreversibility, and the approval requirement.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Completeness3/5
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
The description covers purpose and key behavioral caveats, but leaves the parameter semantics fully to the schema, and there is no output schema or return-value explanation. For a simple destructive operation this may be acceptable, but the lack of any parameter guidance and no description of the expected response/result makes it only minimally complete.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Parameters2/5
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
Schema description coverage is 0%, and the description does not mention either parameter (quarantineRelativePath or rootIndex). It provides no additional meaning beyond the schema fields, which are self-descriptive but not explained. The description's reference to an 'item' vaguely implies the path parameter but does not compensate for the lack of schema documentation.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Purpose5/5
Does the description clearly state what the tool does and how it differs from similar tools?
The description clearly states the action ('Permanently delete') and the target ('item that already lives in the quarantine directory'). It distinguishes this tool from siblings like whatbox_list_quarantine and whatbox_quarantine_path by specifying it's the irreversible second step.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Usage Guidelines4/5
Does the description explain when to use this tool, when not to, or what alternatives exist?
The description provides clear context: it is the irreversible second step after quarantine and requires explicit human approval. This implies usage after whatbox_quarantine_path, though it doesn't explicitly name alternatives or say 'use when not to use'. The 'already lives in quarantine' condition adds a usage constraint.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Behavior4/5
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
Annotations already declare readOnlyHint=true and destructiveHint=false, but the description adds useful behavioral constraints: it does not read file contents, avoids sensitive directories and symlinks, and is bounded. This goes beyond annotations by specifying what the tool deliberately avoids, which is valuable for safe invocation.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Conciseness5/5
Is the description appropriately sized, front-loaded, and free of redundancy?
The description is a single, front-loaded sentence of 19 words. It conveys the action, resource, constraints, and safety properties without redundancy. Every phrase adds meaning, making it highly concise and structured.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Completeness4/5
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
The tool is moderately complex with 3 parameters, no schema descriptions, but an output schema present. Annotations cover safety, and the description explains the core behavior and key boundaries. Minor gaps remain around parameter semantics and the precise meaning of 'allowed root', but overall it is sufficiently complete for a read-only mapping tool.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Parameters3/5
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
Schema description coverage is 0%, so the description must compensate. It partially does by mentioning 'bounded' and 'below an allowed root', hinting at maxDepth, maxNodes, and rootIndex. However, it does not explicitly map each parameter to its purpose or explain how they interact, leaving room for misinterpretation.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Purpose5/5
Does the description clearly state what the tool does and how it differs from similar tools?
The description clearly states a specific action and resource: 'Create a bounded directory-only map and Mermaid diagram'. It also defines scope constraints ('below an allowed root', 'without reading file contents', 'not traversing sensitive directories or symlinks'), which distinguishes it from sibling tools like whatbox_list_directory that likely list files and contents.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Usage Guidelines3/5
Does the description explain when to use this tool, when not to, or what alternatives exist?
The description implies usage for safely mapping a directory structure without reading files, but it does not explicitly state when to use this tool versus alternatives or provide exclusions. There is no mention of 'use when...' or 'prefer this over...', leaving the usage context implicit.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Behavior4/5
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
Annotations already declare destructiveHint=true, but the description adds critical context: 'Requires explicit human approval' and 'deleting data is irreversible.' This goes beyond the structured hints and informs the agent of an approval step and permanent consequences.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Conciseness5/5
Is the description appropriately sized, front-loaded, and free of redundancy?
Two concise sentences lead with the verb and purpose, immediately state the optional deletion, and add the critical human approval warning. No filler or redundancy.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Completeness4/5
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
For a simple destructive tool with no output schema, the description covers the action, the optional data deletion, and the need for approval. It does not describe the return value or post-removal state, but these are likely obvious for a removal operation. Overall, it is sufficiently complete.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Parameters3/5
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
Schema coverage is 0%, so the description must compensate. It explains the deleteData parameter as 'optionally deleting its downloaded data,' but does not elaborate on torrentId beyond what its name implies. The description adds some semantic value but does not fully cover both parameters.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Purpose5/5
Does the description clearly state what the tool does and how it differs from similar tools?
The description clearly states the specific action: 'Remove a torrent from the client' and distinguishes it from siblings like whatbox_torrent_add, whatbox_torrent_control, and whatbox_torrents_status. It also mentions the optional deletion of downloaded data, which adds precision.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Usage Guidelines3/5
Does the description explain when to use this tool, when not to, or what alternatives exist?
The description implies usage for removing torrents but does not explicitly state when to use this versus alternatives. It lacks exclusions or comparative guidance, though the purpose is self-evident among siblings.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Behavior4/5
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
Beyond the annotations, the description adds valuable behavioral context: it creates missing parents and is explicitly reversible. While it does not mention failure modes or permission requirements, for a simple mutation tool this is 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.
Conciseness5/5
Is the description appropriately sized, front-loaded, and free of redundancy?
Two short sentences, front-loaded with the core purpose, and no filler. Every clause adds value: parent creation, root bound, and reversibility.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Completeness4/5
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
For a simple two-parameter tool with no output schema, the description covers the essential operation, its root constraint, and reversibility. The main small gap is the lack of explanation for rootIndex, but the default value and tool name help fill it.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Parameters2/5
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
Schema description coverage is 0%, so the description should compensate for parameter meaning. It only indirectly hints that relativePath is relative to an allowed root and does not explain rootIndex or how roots are selected. This leaves the main parameter semantics under-specified.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Purpose5/5
Does the description clearly state what the tool does and how it differs from similar tools?
The description starts with the specific action 'Create a directory' and adds key scope details: missing parents are created and the operation is confined below an allowed root. This makes its purpose distinct from sibling tools like whatbox_list_directory or whatbox_move_path.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Usage Guidelines4/5
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 a directory (and its parents) needs to be created under an allowed root. It does not explicitly list alternatives or exclusion cases, but the action is simple and the sibling tool names are sufficiently distinct.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Behavior3/5
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
Annotations already declare readOnlyHint=true, idempotentHint=true, and destructiveHint=false, and the description reinforces read-only with 'fixed read-only query.' However, it adds no new behavioral context beyond annotations, such as required permissions or the fact that no parameters are needed. The output schema covers return values, so the description's lack of extra context is acceptable but not exceptional.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Conciseness5/5
Is the description appropriately sized, front-loaded, and free of redundancy?
The description is a single sentence that immediately states the function ('Report capacity and usage') and includes relevant qualifiers ('configured Whatbox storage roots', 'fixed read-only query') without any wasted words.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Completeness5/5
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
For a tool with no parameters and an existing output schema, the description is fully sufficient. It clearly identifies the purpose and scoping ('configured roots'), and the output schema covers return values. The read-only nature is reinforced, and the tool is simple enough that no additional context is needed.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Parameters4/5
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
The tool has no parameters, and the input schema is empty, so the schema provides 100% coverage. The description's phrase 'fixed read-only query' clarifies that no customization is expected, aligning with the empty schema. With zero parameters, this dimension is automatically well-served; the description adds minimal but sufficient context.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Purpose5/5
Does the description clearly state what the tool does and how it differs from similar tools?
The description uses the specific verb 'Report' and clearly identifies the resource: 'capacity and usage for configured Whatbox storage roots.' This distinguishes it from sibling tools like whatbox_structure_map (structure) or whatbox_services_status (service status), which focus on other aspects.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Usage Guidelines3/5
Does the description explain when to use this tool, when not to, or what alternatives exist?
The description implies usage as a read-only storage status check ('configured Whatbox storage roots using a fixed read-only query'), but it does not explicitly state when to use this tool over alternatives or mention any exclusions. No alternative tools are referenced.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Behavior3/5
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
The description adds 'Reversible' beyond the annotations, providing helpful extra context. Annotations already indicate it is not read-only and not destructive, but the reversibility claim is a useful additional trait. However, it does not disclose other potential side effects or permission requirements.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Conciseness5/5
Is the description appropriately sized, front-loaded, and free of redundancy?
The description is a single sentence that lists all operations and adds a relevant note about reversibility. No wasted words.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Completeness3/5
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
The description covers the core operations but does not specify which parameters are required for each operation (e.g., label for set_label) or provide return value/error behavior. Given the 4-parameter schema and lack of output schema, some gaps remain, but the tool is simple and annotations help.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Parameters4/5
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
Schema coverage is 0%, and the description compensates by explaining that 'label' means category and by mentioning the seed-ratio limit. It also lists the operation enum values in prose. The torrentId is self-explanatory, and operation details are covered by the enum.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Purpose5/5
Does the description clearly state what the tool does and how it differs from similar tools?
The description clearly states the tool's function with a specific verb and resource: pausing, resuming, setting label/category, or setting seed-ratio limit on a torrent. It distinguishes itself from sibling tools like whatbox_torrent_add, whatbox_torrent_remove, and whatbox_torrents_status.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Usage Guidelines4/5
Does the description explain when to use this tool, when not to, or what alternatives exist?
The description provides clear context by listing the operations, implying it should be used when these actions are desired. It does not explicitly mention alternatives or exclusions, but the phrase 'one torrent' and the operation list give sufficient guidance.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Behavior4/5
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
Annotations already declare readOnlyHint=true and destructiveHint=false. The description adds meaningful behavioral context: 'allowlisted', 'redacted, signed', and reinforces no state changes. This goes beyond the structured annotations without contradicting them. It could mention validation failure handling, but the output schema likely covers that.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Conciseness5/5
Is the description appropriately sized, front-loaded, and free of redundancy?
Two sentences with no filler. The first sentence immediately states the action and resource; the second clarifies the safety boundary. Every clause adds value.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Completeness4/5
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
The description covers the core purpose, safety profile, and adds specific details like allowlisting and redaction. Annotations and output schema cover the remaining behavioral and return information. It is slightly incomplete regarding when to use this versus the many sibling tools, but that is more of a usage guideline issue already scored.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Parameters2/5
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
Schema description coverage is 0%, so the description must compensate for all three parameters. It only addresses 'sourceRoot' implicitly via 'source', leaving 'releaseId' and 'rootIndex' completely unexplained. The description adds minimal meaning beyond the parameter names.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Purpose5/5
Does the description clearly state what the tool does and how it differs from similar tools?
The description uses specific verbs ('Validate', 'create') and identifies the resource ('local static-site source', 'deployment plan'). It explicitly states the tool never uploads files or changes Whatbox state, which distinguishes it from deploy_execute and rollback siblings. This is a clear, non-tautological purpose.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Usage Guidelines4/5
Does the description explain when to use this tool, when not to, or what alternatives exist?
The description implies this is a pre-deployment planning step by saying it does not upload or change state. However, it does not explicitly name alternatives or state when not to use it. The sibling list provides context, but the tool could be confused with readiness or diagnostics tools without more explicit direction.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Behavior4/5
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
Annotations already declare readOnlyHint=true, idempotentHint=true, and destructiveHint=false, so the safety bar is lower. The description adds valuable behavioral context: 'without returning configuration or log contents' and 'without a response body' clarify output limitations and privacy safeguards, which goes beyond annotations.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Conciseness4/5
Is the description appropriately sized, front-loaded, and free of redundancy?
The description is a single, information-dense sentence covering three distinct actions while staying under 30 words. It is front-loaded with the primary purpose. Slightly complex sentence structure, but every clause earns its place, so it merits a 4.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Completeness4/5
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
Given no parameters, strong annotations, and the presence of an output schema, the description is largely complete. It covers the main diagnostic behaviors and explicitly notes what the tool will not return. Some preconditions (e.g., existence of a userland Nginx config) are not stated, but that does not significantly hinder invocation.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Parameters4/5
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
The tool has zero parameters, so schema coverage is trivially 100%. The description effectively conveys the optional probing behavior and the non-content-returning nature, making parameter explanation unnecessary. Baseline 4 is appropriate.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Purpose5/5
Does the description clearly state what the tool does and how it differs from similar tools?
The description uses specific verbs ('Test', 'probe', 'summarize') and identifies exact resources (userland Nginx configuration, loopback port, error severities). It completely avoids tautology and clearly distinguishes itself from sibling tools like whatbox_website_readiness by focusing on syntax testing and error severity summarization.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Usage Guidelines3/5
Does the description explain when to use this tool, when not to, or what alternatives exist?
The description implies usage for safe diagnostic checks (read-only, no content return) but does not explicitly state when to use this tool versus alternatives, nor does it mention any exclusions or prerequisites. The lack of explicit guidance prevents a higher score.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Behavior4/5
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
Annotations provide no safety hints (all false). The description adds valuable behavioral context: it checks local free space first and returns only counts, which is beyond what the schema or annotations convey.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Conciseness5/5
Is the description appropriately sized, front-loaded, and free of redundancy?
Two concise, front-loaded sentences. No filler, every clause adds value (destination, timestamping, output format, precondition).
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Completeness4/5
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
For a simple one-parameter tool with no output schema, the description covers the main action, destination, return type, and a precondition. It lacks details like overwrite behavior or remote-side effects, but these are less critical for this tool type.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Parameters4/5
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
With 0% schema description coverage, the description partially compensates by mentioning 'service configuration directories', which implies the 'services' parameter selects which services to back up. It also clarifies the allowlist concept, but does not explicitly tie the parameter to the action.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Purpose5/5
Does the description clearly state what the tool does and how it differs from similar tools?
The description states a specific verb ('Download'), a clear resource ('service configuration directories'), and a destination ('local download directory'), distinguishing it from read-only sibling tools like whatbox_configuration_status.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Usage Guidelines3/5
Does the description explain when to use this tool, when not to, or what alternatives exist?
The description implies usage context (backing up configurations), but it does not explicitly state when to use this tool over alternatives or mention any exclusions. Sibling differentiation is implicit via the tool name and action, but not directly addressed.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Behavior5/5
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
The description discloses key behavioral traits beyond the annotations, including free-space checking, checksum verification, atomic activation, health-checking, and reversibility. This adds valuable context for an agent deciding whether this tool is safe and appropriate; it also does not contradict the provided annotations.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Conciseness5/5
Is the description appropriately sized, front-loaded, and free of redundancy?
The description is two focused sentences, front-loaded with the primary action and enriched with the key operational details. Every clause adds needed context without redundancy or wasted words.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Completeness3/5
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
The description gives a solid operational overview including safety and reversibility, but it lacks any explanation of return values, failure behavior, or how to obtain/interpret 'releaseId' and 'sourceRoot'. Given the absence of an output schema and zero parameter documentation, the description is not fully sufficient for correct invocation.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Parameters2/5
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
The schema has no parameter descriptions, and the description only indirectly hints at 'sourceRoot' through 'local static site' and at 'releaseId' through 'new release'. The optional 'rootIndex' parameter is not mentioned at all, so the description provides minimal meaning beyond the bare schema names.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Purpose5/5
Does the description clearly state what the tool does and how it differs from similar tools?
The description clearly identifies the tool as executing a static website deployment, using specific verbs like 'Stage', 'verify', 'atomically activate', and 'health-check'. It distinguishes itself from sibling tools such as whatbox_website_rollback and whatbox_website_deployment_plan by describing its unique role in the deployment lifecycle.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Usage Guidelines4/5
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 (after validation, before rollback) and explicitly mentions rollback as a reversal option. It does not, however, explicitly state exclusions or prerequisites such as 'do not use if the site has not been validated' or 'use the deployment plan tool first'.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Behavior3/5
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
Annotations already declare readOnlyHint=true, idempotentHint=true, and destructiveHint=false, so the safety profile is well covered. The description adds the notion of 'safety boundaries,' which is some extra context, but does not disclose any additional operational behavior or side effects beyond what annotations already provide.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Conciseness5/5
Is the description appropriately sized, front-loaded, and free of redundancy?
The description is a single, front-loaded sentence that efficiently specifies the three content areas without any filler. Every word earns its place, making it highly concise and easy to parse.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Completeness5/5
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
For a zero-parameter tool with an output schema, the description sufficiently conveys what the tool provides: implemented capabilities, planned integrations, and safety boundaries. It is complete enough for an agent to know what to expect when invoking this tool.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Parameters4/5
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 empty input schema means there is no parameter syntax to explain, and the description does not need to compensate for any undocumented parameters.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Purpose5/5
Does the description clearly state what the tool does and how it differs from similar tools?
The description clearly states that the tool lists implemented capabilities, planned Whatbox integrations, and safety boundaries. The verb 'list' and the three specific content areas make the purpose unambiguous, and it distinguishes itself well from the many sibling tools that perform individual operations.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Usage Guidelines4/5
Does the description explain when to use this tool, when not to, or what alternatives exist?
The description implies this tool is for gaining an overview of the server's capabilities and safety limits, which provides clear context for when to use it. However, it does not explicitly name alternatives or state when not to use other tools, so it stops short of a perfect score.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Behavior4/5
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
Annotations already declare readOnlyHint, idempotentHint, and destructiveHint, but the description adds valuable context: 'conservative advisory findings' and the explicit exclusion of reading configuration contents. This goes beyond the generic annotation hints, clarifying the tool's cautious scope.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Conciseness5/5
Is the description appropriately sized, front-loaded, and free of redundancy?
The description is a single, front-loaded sentence that provides the verb, scope, and key limitations without redundancy. Every element earns its place.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Completeness5/5
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
With no parameters and an output schema present, the description covers purpose, behavior, and boundaries effectively. It does not need to explain return values, and the annotations complete the safety profile.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Parameters4/5
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 appropriately omits parameter details, and the empty schema leaves nothing to explain.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Purpose5/5
Does the description clearly state what the tool does and how it differs from similar tools?
The description clearly states the tool returns conservative advisory findings sourced from service metadata and storage capacity. It uses the specific verb 'Return' and distinguishes itself from siblings by explicitly noting it does not read configuration contents or make changes.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Usage Guidelines3/5
Does the description explain when to use this tool, when not to, or what alternatives exist?
The description implies the tool is for when users need an advisory assessment without accessing raw config data. However, it does not explicitly name alternative tools or state when-not-to-use, leaving the usage context somewhat implied.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Behavior4/5
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
The annotations already declare readOnlyHint, idempotentHint, and non-destructive nature. The description adds valuable context beyond these by stating it does not return configuration values or secrets, which is a behavioral guarantee not captured in the annotations. This enriches the safety profile.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Conciseness5/5
Is the description appropriately sized, front-loaded, and free of redundancy?
The description is a single, well-structured sentence that conveys the tool's purpose and key behavioral constraint without superfluous words. Every word earns its place.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Completeness5/5
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
Given the tool's simple nature (zero params), the existence of an output schema (which would document return values), and the rich annotations, the description provides sufficient context. It covers the essential safety behavior (not returning secrets) and leaves return details to the output schema.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Parameters4/5
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
The tool has zero parameters and an empty schema, so the baseline is 4. The description adds no parameter-specific information, but none is needed since there are no parameters to document.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Purpose5/5
Does the description clearly state what the tool does and how it differs from similar tools?
The description clearly states the tool checks the completeness of local Whatbox configuration with the specific verb 'Check' and identifies the resource. It also explicitly distinguishes itself from tools like whatbox_configuration_review by noting it does not return configuration values or secrets, making its purpose unambiguous.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Usage Guidelines3/5
Does the description explain when to use this tool, when not to, or what alternatives exist?
The usage context is implied: it is a safe check that avoids exposing secrets, but there is no explicit guidance about when to use it versus alternatives like whatbox_configuration_review. It does not state exclusions or recommend this tool over siblings, leaving the when-to-use somewhat implicit.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Behavior4/5
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
Annotations already declare readOnlyHint=true and destructiveHint=false, but the description adds meaningful behavioral context: it uses 'local credentials' and does not return their values. This goes beyond the structured data and tells the agent what to expect, though it doesn't detail failure behavior or output specifics.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Conciseness5/5
Is the description appropriately sized, front-loaded, and free of redundancy?
The description is a single sentence that is front-loaded with the key action and resource. Every word earns its place: 'Test', 'verified read-only SSH connection', 'using local credentials without returning their values' – no redundancy or filler.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Completeness5/5
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
Given the tool's simplicity (no parameters, rich annotations, and an output schema), the description covers all essential aspects: what it tests, the read-only nature, and credential privacy. It is complete for an agent to select and invoke it correctly.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Parameters4/5
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
The tool has zero parameters, so there is no schema burden. The description's mention of 'local credentials' clarifies that no parameter input is needed, aligning with the empty schema. The baseline for 0 params is 4, and the description adds minimal but relevant context about credential handling.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Purpose5/5
Does the description clearly state what the tool does and how it differs from similar tools?
The description uses a specific verb ('Test') and resource ('SSH connection') and adds scoping details ('verified read-only', 'using local credentials without returning their values'). This clearly distinguishes it from sibling tools like whatbox_services_status or whatbox_configuration_status, which check other aspects.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Usage Guidelines3/5
Does the description explain when to use this tool, when not to, or what alternatives exist?
The description implies usage: verifying readiness of an SSH connection. It doesn't explicitly state when to use this tool over alternatives, but no sibling tool tests SSH connectivity directly, so the implied context is sufficient for basic guidance. It lacks explicit 'when not to use' or alternative references.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Behavior5/5
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
Despite destructiveHint=true in annotations, the description adds crucial behavioral nuance: 'Requires explicit human approval,' 'Reversible,' and 'reports storage headroom (quarantine does not free space).' These clarify the operational consequences beyond the raw annotation, giving the agent a fuller picture of what to expect.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Conciseness5/5
Is the description appropriately sized, front-loaded, and free of redundancy?
The description is compact and front-loaded. The first clause immediately states the core action, with subsequent clauses covering approval, reversibility, and storage impact. Each sentence adds value without unnecessary fluff, making it highly efficient.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Completeness4/5
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
The description covers the main action, approval requirement, reversibility, and storage behavior, which is strong for a simple tool. Given the absence of an output schema, it mentions 'reports storage headroom' as a hint but doesn't detail the return format or explain rootIndex. More on the expected response would make it fully complete.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Parameters2/5
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
Schema description coverage is 0%, so the description carries the full burden of explaining parameters. It only mentions 'a path' generically, leaving relativePath (required) and especially rootIndex (optional, with default) unexplained. This is insufficient for 2 parameters with no schema descriptions.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Purpose5/5
Does the description clearly state what the tool does and how it differs from similar tools?
The description clearly states the action: 'Move a path into a dated quarantine directory instead of deleting it.' This uses a specific verb (move), resource (path), and destination (quarantine directory), and distinguishes the tool from siblings like whatbox_purge_quarantine by positioning it as a soft-delete alternative.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Usage Guidelines4/5
Does the description explain when to use this tool, when not to, or what alternatives exist?
The phrase 'instead of deleting it' implies the appropriate context (when you want a reversible removal) and the caveat 'quarantine does not free space' warns against using it to free storage. However, it does not explicitly name alternative tools (e.g., whatbox_purge_quarantine) or state exclusion conditions, so some guidance is left implicit.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Behavior4/5
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
Annotations already declare readOnlyHint, idempotentHint, and destructiveHint, so the safety profile is covered. The description adds valuable context beyond annotations by stating it avoids reading configuration contents or process arguments, which is a security-relevant behavioral guarantee. 'Conservative' also signals a cautious reporting approach, adding transparency.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Conciseness5/5
Is the description appropriately sized, front-loaded, and free of redundancy?
The description is a single, dense sentence that front-loads the action ('Report') and immediately conveys the resource and key constraints. Every word earns its place, with no redundant or filler content.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Completeness5/5
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
For a zero-parameter status tool with an output schema and comprehensive annotations, the description is complete. It clearly defines the tool's scope (allowlisted service catalog) and explicitly states what it avoids (reading configs/arguments), which is especially useful given the large family of sibling status tools. Return values are covered by the output schema.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Parameters4/5
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 does not need to explain parameter syntax, but it clarifies the resource scope (allowlisted services) and the behavioral constraints, which is sufficient given the empty schema.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Purpose5/5
Does the description clearly state what the tool does and how it differs from similar tools?
The description uses a specific verb ('Report') and resource ('configured and running states for an allowlisted Whatbox service catalog'), and adds a distinguishing qualifier ('without reading configuration contents or process arguments') that separates it from configuration-focused siblings like whatbox_configuration_status. This fully clarifies 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.
Usage Guidelines3/5
Does the description explain when to use this tool, when not to, or what alternatives exist?
The description implies scope through 'allowlisted' and the no-read caveat, but it does not explicitly state when to use this tool versus alternatives like whatbox_torrent_clients_status or whatbox_storage_status. There is no 'use this when' or 'instead of' guidance, so it falls short of being a clear usage guideline.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Behavior4/5
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
Annotations already declare safe read-only/idempotent behavior. Description adds meaningful scope context ('fixed facts') and exclusion of sensitive internals, reinforcing what the operation covers and avoids. No contradiction found.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Conciseness5/5
Is the description appropriately sized, front-loaded, and free of redundancy?
Single sentence, front-loaded with the action verb, and every clause earns its place. The negative scope clarifies without verbosity.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Completeness5/5
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
With zero parameters, strong annotations (readOnly/idempotent), and an output schema present, the description fully covers the tool's purpose and boundaries. No additional information is necessary.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Parameters4/5
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
Tool has zero parameters, so schema coverage is 100% by default. Description correctly avoids inventing parameter details; no parameter explanation needed.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Purpose5/5
Does the description clearly state what the tool does and how it differs from similar tools?
Description uses specific verb 'Inspect' with clear resource 'website-hosting readiness facts'. Explicitly distinguishes from siblings by stating it does NOT read Nginx config, process arguments, or private connection values, separating it from diagnostics tools.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Usage Guidelines3/5
Does the description explain when to use this tool, when not to, or what alternatives exist?
Usage is implied rather than explicit. The negative constraints hint when NOT to use (if Nginx config contents, process args, or private values are needed), but no alternative tools are named or explicit when-to-use guidance provided.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Behavior4/5
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
Annotations already declare readOnly, idempotent, and non-destructive behavior. The description adds context about the content: grouping by category/risk and the remote mutations flag. This helps the agent understand what data to expect, going beyond the annotation-only safety profile.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Conciseness5/5
Is the description appropriately sized, front-loaded, and free of redundancy?
Two sentences, each earning its place: one states the core function and output organization, the other gives a direct usage context. No filler or redundancy.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Completeness5/5
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
With no parameters and an output schema available, the description fully covers what the tool does and its intended use. The mention of grouping and remote-mutation status is sufficient contextual detail for an agent to invoke it correctly.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Parameters4/5
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
The tool has zero parameters, so there is nothing to document. Per rubric, baseline for 0 parameters is 4. The description adds no parameter-specific information because none is needed.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Purpose5/5
Does the description clearly state what the tool does and how it differs from similar tools?
The description clearly states the tool returns the full tool catalog, grouped by category and risk, and indicates whether remote mutations are enabled. This is specific and distinguishes it from siblings like list_capabilities. The verb 'Return' plus resource 'full tool catalog' makes the purpose explicit.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Usage Guidelines4/5
Does the description explain when to use this tool, when not to, or what alternatives exist?
The description explicitly ties the tool to backing the '/tools' command, giving a clear use case. It does not explicitly name alternatives or when-not-to-use, but the context is sufficient for an agent to select this tool for catalog listing. The lack of exclusionary guidance prevents a 5.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Behavior4/5
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
Annotations already declare readOnlyHint=true, destructiveHint=false, and idempotentHint=true. The description reinforces 'read-only' and adds context about 'sanitized' output and 'mutation safety state', providing useful behavioral nuance beyond the annotations.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Conciseness5/5
Is the description appropriately sized, front-loaded, and free of redundancy?
The description is a single, well-structured sentence that lists the covered subjects without unnecessary filler. Every word adds value.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Completeness5/5
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
For a zero-parameter read-only tool with annotations and an output schema, the description adequately maps the scope of the assessment. It mentions storage pressure, services, website readiness, recommendations, and mutation safety, covering the major areas an operational snapshot would include.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Parameters4/5
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 appropriately does not attempt to document parameters that do not exist.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Purpose5/5
Does the description clearly state what the tool does and how it differs from similar tools?
The description clearly states that the tool returns a read-only assessment covering five specific areas, which is a specific verb+resource combination. It distinguishes itself from the many individual status sibling tools by presenting a consolidated snapshot.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Usage Guidelines4/5
Does the description explain when to use this tool, when not to, or what alternatives exist?
The description provides clear context: this is a consolidated assessment covering multiple subsystems. It implies a use case of gaining a broad overview, but does not explicitly mention when not to use it or alternatives for more detailed checks.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Behavior4/5
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
Annotations already declare readOnlyHint, idempotentHint, and destructiveHint, which covers safety. The description adds valuable behavioral detail: it states the output is scoped to only allowlisted client running states, explicitly not including torrent details or unrelated processes. This goes beyond the annotations and clarifies what the tool will not reveal.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Conciseness5/5
Is the description appropriately sized, front-loaded, and free of redundancy?
The description is a single, well-structured sentence that states the action, the target, and the scope/exclusions, all 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.
Completeness5/5
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
Given zero parameters, a rich set of annotations, and an output schema (indicated), the description provides enough context for an agent to understand what this tool does and its position among siblings. The focus on checking client status versus torrent status is clearly communicated, making it complete for a simple status-check tool.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Parameters4/5
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
This tool has zero parameters, so the schema is trivially 100% covered. Per guidelines, a zero-parameter tool receives a baseline score of 4. The description correctly focuses on behavior rather than input, which is appropriate for a no-parameter report.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Purpose5/5
Does the description clearly state what the tool does and how it differs from similar tools?
The description uses a specific verb ('Report') and resource ('allowlisted Whatbox torrent clients') and clearly defines scope: 'without returning torrent or unrelated process details.' This distinguishes it from sibling tools like whatbox_torrents_status, which presumably reports on torrents themselves, and other status tools.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Usage Guidelines4/5
Does the description explain when to use this tool, when not to, or what alternatives exist?
The description clearly implies when to use this tool: when you need to know if torrent client processes are running, not torrent data. The explicit exclusion of 'torrent or unrelated process details' provides context for why you'd choose this over a broader status tool. However, it doesn't explicitly name an alternative or provide a direct 'use when' instruction.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.

GitHub Badge

Glama performs regular codebase and documentation scans to:

Confirm that the MCP server is working as expected.
Confirm that there are no obvious security issues.
Evaluate tool definition quality.

Our badge communicates server capabilities, safety, and installation instructions.

Card Badge

Copy to your README.md:

[![whatbox-mcp MCP server](https://glama.ai/mcp/servers/SNSEIxAUGMNTD/whatbox-mcp/badges/card.svg)](https://glama.ai/mcp/servers/SNSEIxAUGMNTD/whatbox-mcp)

Score Badge

Copy to your README.md:

[![whatbox-mcp MCP server](https://glama.ai/mcp/servers/SNSEIxAUGMNTD/whatbox-mcp/badges/score.svg)](https://glama.ai/mcp/servers/SNSEIxAUGMNTD/whatbox-mcp)

Latest Blog Posts

Who's Calling? MCP Hosts Are an Identity Blind Spot (And the Spec Knows It)
By Om-Shree-0709 on July 25, 2026.
mcp
Agent Identity
OAuth 2.1
Your AI Chatbot Just Exposed Your CEO's Salary to an Intern
By Om-Shree-0709 on July 2, 2026.
Agent Identity
MCP Security
OAuth Delegation
Why MCP Servers Need Execution Sandboxing (And Why Your Current Stack Isn't Enough)
By Om-Shree-0709 on June 30, 2026.
Agentic Ai
Prompt Injection
WebAssembly

MCP directory API

We provide all the information about MCP servers via our MCP API.

curl -X GET 'https://glama.ai/api/mcp/v1/servers/SNSEIxAUGMNTD/whatbox-mcp'

If you have feedback or need assistance with the MCP directory API, please join our Discord server