keenetic

by Kykyryky23

Overview Schema Related Servers Score Discussions

TypeScript

Local

Server Quality Checklist

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

Latest release: v1.1.0
Disambiguation4/5
Most tools map to distinct resource-action pairs; retrieval tools (get_interfaces, get_wan_status, list_devices, list_wifi_clients) have overlapping data but are clearly separated by what they serve. A few ambiguous boundaries remain, like list_devices versus list_wifi_clients or VPN list as a subset of interfaces.
Naming Consistency4/5
Naming mostly follows a consistent snake_case verb_noun structure, mixing get_/list_ for reads, set_/add_/remove_ for modifications, plus a few extra verbs like check_/bind_/reboot_. The only minor inconsistency is using get_interfaces for a collection rather than list_interfaces, but the overall pattern is predictable.
Tool Count3/5
With 22 tools, the server exceeds the typical 3-15 well-scoped range; many tools are needed for the router domain, though the count feels heavy. Each area (interfaces, WiFi, port forwards, routes, VPN) has its own set, so it's borderline. The number isn't extreme and tools generally earn their place.
Completeness3/5
The toolbox gives solid coverage for routes and port forwards with read/modify/delete actions, plus system and status. However, DHCP reservations are only listed, not editable, and firmware update handling stops after the check, leaving a notable gap in the management surface.
Average 3.6/5 across 22 of 22 tools scored. Lowest: 2.9/5.
See the Tool Scores section below for per-tool breakdowns.
- No community issues in the last 6 months
- No commit activity data available
- Last stable release on August 23, 2026
- No critical vulnerability alerts
- No high-severity vulnerability alerts
- No code scanning findings
- CI status not available
Add a LICENSE file by following GitHub's guide. Once GitHub recognizes the license, the system will automatically detect it within a few hours.
If the license does not appear after some time, you can manually trigger a new scan using the MCP server admin interface.
MCP servers without a LICENSE cannot be installed.
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

Behavior2/5
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
Annotations already declare readOnlyHint=false, idempotentHint=true, and destructiveHint=false, covering the write and safety profile. The description adds no behavioral context such as the two-phase confirm/dryRun mechanism, the fact that a call without confirm does nothing, or any router-side effect, so it adds no transparency 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 short sentence with the action immediately declared. No wasted words and no redundant restatement of schema fields or sibling names, making it a model of concise, front-loaded structure.
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 five parameters, a mandatory confirm gating behavior, and no output schema, the description is too sparse to tell the agent how to confidently invoke it. Critical semantics like preview-vs-apply and expected result are missing; the environment has to instead rely on the surrounding schema to understand the tool's full contract.
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 100%, with five parameters already documented, including the confirm and dryRun semantics. The description contributes nothing about these parameters, and thus stays at the baseline of 3 rather than earning additional credit.
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 uses a specific verb ('adds') and a specific resource ('static route'), making its core purpose unambiguous. It is naturally distinguished from siblings like remove_route, list_routes, and bind_route_to_vpn, though it never explicitly points to what it is not.
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?
The description provides no guidance about when to choose add_route over alternatives such as run_route_batch or bind_route_to_vpn, and it fails to mention the critical requirement that confirm=true is necessary to actually apply the route. The agent must infer timing from the schema, not the description.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Behavior2/5
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
With no annotations to rely on, the description carries the full behavioral burden and it only says 'current port forwarding rules'. It does not disclose that the tool reads without side effects, what shape the result takes, whether it reflects active/effective rules, or how it is affected by siblings such as add_port_forward.
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 very short and front-loaded, with no filler words or structural complexity. It is concise, though it gets some conciseness from omitting the explicit verb rather than from being a complete, clear sentence.
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 zero-parameter list tool, naming the resource is enough to make the tool callable. However, the absence of an output schema and annotations means the agent still lacks clarity about what the tool returns and what guarantees it offers beyond the label.
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 input schema has zero parameters, so there are no parameter semantics to document. The baseline of 4 applies because no parameter information is needed and nothing is missing on that front.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Purpose3/5
Does the description clearly state what the tool does and how it differs from similar tools?
The description identifies the resource being acted on (current port forwarding rules) but uses a noun phrase rather than an explicit verb like 'list' or 'retrieve'. The agent can infer the action from the tool name and title, but the description itself does not state it, so the purpose is somewhat implicit.
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 or why it should be preferred over related tools. The sibling tools add_port_forward and remove_port_forward suggest a read/modify split, but that distinction must be inferred rather than stated.
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 cover the safety profile with readOnlyHint=false, destructiveHint=false, and idempotentHint=true, so the description does not need to restate basic safety. It adds the core behavioral effect ('removes binding') but does not mention reversibility side effects, or any need to satisfy confirmation conditions beyond what the schema provides.
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 efficient sentence that immediately states the action and target. It has no fluff or redundancy, and all words carry 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 simple mutation tool, the description conveys the main effect, and the schema provides additional details about dryRun and confirm. However, it does not clarify that the operation depends on confirm=true, nor does it mention the relationship to bind_route_to_vpn, so the agent must infer some workflow context.
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 input schema has descriptions only for dryRun and confirm, leaving network and mask effectively undocumented. The description mentions 'network' as the target of the unbinding, but it does not explain the network/mask pairing or how these identify the route. With only 50% schema coverage, the description does not adequately compensate.
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 action ('removes the binding') and the resource ('network to VPN interface'), so an agent can understand the core operation. It is distinguishable from sibling tools like remove_route and bind_route_to_vpn by its wording, although it does not explicitly name the counterpart.
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?
The description provides no guidance on when to use this tool versus alternatives such as bind_route_to_vpn, add_route, or remove_route. It relies on the tool name and the agent's inference, rather than explicit when-to-use or when-not-to-use instructions.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Behavior2/5
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
There are no annotations, so the description must disclose behavioral traits, but it only defines a domain concept. It does not state that the tool enumerates reservations, whether it is a read-only operation, what ordering or filtering is applied, or what response shape to expect and rejection. The phrase adds semantic context but not behavioral transparency.
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 short fragment with no filler and communicates the core concept efficiently. It is still somewhat under-specified as a full instruction, but there is nothing redundant here.
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 zero-parameter tool, the description is minimally sufficient: combined with the name it tells the agent what resource is involved. However, it does not describe the expected list output, scope of reservations, or side effects, and there is no output schema to fill that gap.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Parameters4/5
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
No parameters exist, so the description has no obligation to document param meaning. Baseline 4 is appropriate for a zero-parameter tool.
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?
Description 'Статические привязки IP к MAC' clearly identifies the resource (DHCP reservations) and adds domain meaning (static IP-to-MAC bindings), which distinguishes it from general device listing. However, it lacks an explicit verb phrase, relying on the tool name 'list' to carry the action.
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 alternatives such as list_devices or list_wifi_clients. The description only defines what a reservation is; the agent must infer usage context from siblings and name alone.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Behavior2/5
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
There are no annotations, so the description must carry the full behavioral burden. It states that the tool exposes a static route table, implying a read operation, but it does not disclose output shape, ordering, pagination, or whether the result includes only active routes. For a no-parameter list tool this is minimally informative but not fully transparent.
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 short and front-loaded, using only one meaningful phrase. It avoids redundancy with the title while adding the key qualifiers 'static' and 'router', but it could still afford a second clause describing the output.
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 parameterless tool this is close to adequate, but the absence of annotations and an output schema leaves the return format unstated. A simple listing tool should at least indicate whether it returns all static routes and in what form; the current description only names the subject.
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 description need not clarify parameter semantics. A baseline of 4 is appropriate because there is nothing for the schema or description to document.
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 identifies the result as the router's static route table, which clearly maps to the tool name list_routes and distinguishes it from route-mutating siblings like add_route and remove_route. It is concise and resource-specific, though it does not explicitly state that it returns or lists entries.
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 given on when to use this tool instead of sibling listing tools such as list_devices, get_interfaces, or list_vpn_interfaces. The context signals make the tool self-evident as a route reader, but the description provides no explicit usage context or exclusions.
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 establish readOnlyHint=false, idempotentHint=true, and destructiveHint=false, and the description is consistent with these (no contradiction). It does not, however, add any behavioral context beyond them — e.g., that changes only take effect when confirm=true or that the RCI payload can be previewed via dryRun — although those semantics are at least present in the schema parameter descriptions.
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 short Russian sentence with no padding and the action verb front-loaded. It is appropriately small for a verb+resource definition, though it uses none of its space to convey routing guidance or behavioral hints that would raise its value.
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 mutating tool with 4 parameters and no output schema, the description "deletes a static route" is quite thin. It does not indicate what the agent should expect after invocation (result payload, success/failure semantics), that confirm=true is mandatory for applying and dryRun is available for preview sums (these live only in the parameter-level schema), or what happens to routes currently bound to VPNs.
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 50%: dryRun and confirm are well described in the schema itself, so the description only needs to help with network and mask. It implicitly indicates that the two parameters identify a static route, but gives no format guidance (CIDR vs. netmask, IPv4/IPv6). The description therefore adds only marginal value over the schema and does not fully compensate for the two undocumented parameters.
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 states a specific verb ('Удаляет' — deletes) and a specific resource ('статический маршрут' — static route), which is enough to distinguish it from siblings like add_route, list_routes, and bind_route_from_vpn. It adds the qualifier 'статический', which goes slightly beyond the title. However, it never explicitly contrasts with any sibling, so it doesn't fully maximize this dimension.
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?
There is no guidance on when to use this tool versus alternatives such as run_route_batch, remove_port_forward, or unbind_route_from_vpn. The description only states what the tool does, not when it should be chosen, what prerequisites exist (e.g., the route must already exist), or what cases it is not suited for.
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 convey readOnly=false, idempotent=true, and destructive=false, and the description aligns by saying an existing forwarding rule is removed. It adds little beyond the minimal deletion semantic and does not mention side effects such as the port becoming externally unreachable or how confirm/dryRun affect the operation.
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, front-loaded sentence with no filler: the verb and object come first. It is efficiently sized, though its brevity leaves room for more operational detail.
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 flat four-parameter delete operation, the description is minimally sufficient when combined with the schema, but the agent is not told how to identify the exact rule safely or which sibling to consult for listing rules. It is adequate, not comprehensive.
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 50%, with dryRun and confirm already documented in the schema. The description does not explain that proto/externalPort together identify the rule to remove, so it adds only marginal meaning beyond the field names and enum/range constraints.
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 uses a clear verb ('Удаляет') and resource ('ранее созданное правило port forwarding'), so the core action is unambiguous. It is strongly distinguishable from add_port_forward and list_port_forwards, though it does not explicitly name sibling tools for contrast.
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?
The description gives no guidance about when to use this tool versus list_port_forwards, add_port_forward, or remove_route. It also does not mention checking for the rule first or using dryRun/confirm as a safe workflow.
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?
With no annotations provided, the description carries the behavioral burden. It implies a read-only retrieval of telemetry by naming informational fields, but it does not explicitly disclose that no side effects occur, nor does it describe output format, rate limits, or authentication requirements.
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 concise sentence that places the key examples up front. The phrase 'и т.п.' is somewhat low-information, but overall there is no unnecessary repetition or verbose phrasing.
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 zero-parameter informational tool, the description is minimally sufficient: an agent can infer that calling it yields system-level telemetry. Still, because there is no output schema and the description relies on vague examples, the exact contents and structure of the returned system info remain incomplete.
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 accepts zero parameters and schema description coverage is 100%, so there is no parameter ambiguity to explain. The baseline of 4 applies because no parameter details are needed.
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 names the resource as system information and gives concrete content examples: uptime, load, memory. However, it lacks an explicit verb and the trailing 'etc.' leaves the exact scope vague, and it doesn't distinguish this from nearby get-like siblings such as get_version or get_wan_status.
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 given about when to use this tool versus alternatives like get_version or get_wan_status. The description only enumerates information categories and provides no exclusions, prerequisites, or decision heuristics.
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?
There are no annotations, so the description carries the full burden of behavioral disclosure. It communicates what information is returned, but does that not explicitly state that the operation is read-only or has no side effects, although the get_ prefix suggests this and the tool is a trivial no-parameter read.
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 one short, information-dense line with no filler. It would be slightly better if it were a complete sentence with a verb like 'returns', but it is appropriately brief.
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 no-parameter info-getter, this describes the payload adequately. Yet, with no output schema and no comparison to get_system_info, the agent is left to infer the exact return semantics and when to select this over alternative getter tools.
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?
There are no parameters, so the baseline score is naturally 4. The description adds context by specifying the exact output fields, which is all that is actionable for a parameterless tool.
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 names the exact delivered resource: the KeeneticOS version and router model. It identifies the core purpose and is specific enough to be distinct from most siblings, but it does not differentiate from get_system_info, which may also surface firmware/model details.
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 given about when to use this tool instead of a sibling. get_system_info could plausibly overlap with this one, but the description does not mention it or any exclusion criteria.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Behavior2/5
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
No annotations are provided, so the description carries the full burden of behavioral disclosure. It does not state that the operation is read-only, does not describe whether the list is live or cached, and does not say what kind of information is returned for each Wi-Fi client.
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 very short and contains no filler or redundant words. It is easy to parse, though a verb such as 'lists' or 'returns' would have made it more actionable for an agent.
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 zero-parameter list operation, this is close to minimally viable: an agent can infer what kinds of devices are returned. It lacks a clear statement of return fields/format, whether it reflects current association state, and how it differs from list_devices, which creates real ambiguity.
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 parameter semantics for the description to clarify. The empty input schema already covers everything relevant, and no parameter explanation would add value at call time.
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 identifies the resource as devices associated with access points, which clearly points to Wi-Fi clients and helps distinguish it from list_devices or get_interfaces. It is slightly weaker than a 5 because it is a noun phrase rather than an explicit statement like 'Lists all devices currently associated with access points.'
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 intended usage is implied: it is for retrieving/listing devices connected to Wi-Fi access points. However, it does not explicitly say when to prefer this over list_devices, get_interfaces, get_wan_status, or other sibling tools, and gives no usage scenarios or exclusions.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Behavior2/5
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
Annotations indicate this is a write operation, so the basic mutating behavior is already known. However, the description discloses nothing beyond annotations: it fails to note the possibility of preview via dryRun, the mandatory confirm requirement, or the side effect of existing Wi-Fi clients being disconnected when a password is changed. No contradiction with annotations exists.
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 directly explains the core function with no filler. It is front-loaded with the main verb and object and earns its place in the definition.
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?
Together with the fully documented input schema, the tool is invocable correctly if the agent reads xem. However, the description alone does not fully capture the important confirm/dryRun behavior. There is no output schema and no explicit statement of what the tool returns, which leaves some ambiguity about the operation's result. It is adequate but not rich.
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?
The input schema covers all four parameters with clear descriptions, including psk length, interfaceId format, dryRun behavior, and confirm semantics. Schema coverage is 100%, so the description does not need to add much here. It adds no extra meaning beyond what the schema provides, making a baseline score of 3 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 clearly states a specific action: it sets a new WPA-PSK password on a specific access point. This naturally differentiates it from sibling tools like set_wifi_enabled, which toggles Wi-Fi, and other router configuration tools.
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?
The description provides no usage guidance or exclusions. It does not mention when to use this tool instead of alternatives, does not state that confirm must be true to actually apply the change, and does not alert the agent to the dryRun preview option. These important invocation decisions are left fully undeclaremelded.
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?
No annotations are provided, so the description carries the disclosure burden. It clearly represents a read-only state query with no side effects, which is helpful. However, it does not disclose what the status contains, how connectivity is represented, or whether the result is just an up/down flag or richer data.
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 short sentence that immediately conveys the tool's focus. There is no wasted wording or redundant restatement of the tool name.
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 is sufficient for understanding that this is a no-input status read of the main internet connection. However, with no output schema and no behavioral detail, the agent does not learn what kind of state data to expect. This is a moderate gap for a tool whose entire purpose is returning status.
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 provides no parameter semantics to enhance. The description does not need to explain parameters and the baseline of 4 applies well here.
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 resource (main internet/WAN connection) and the purpose (report its state). It differentiates the tool from get_interfaces by emphasizing the primary internet connection rather than the generic interface list. It is slightly terse, but the intent and scope are explicit.
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?
The description gives no explicit guidance about when to use this tool versus siblings such as get_interfaces or get_system_info. There are no alternatives, conditions, or exclusions mentioned, so the decision is left entirely to inference.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Behavior3/5
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
The description is consistent with the annotations: it describes a write operation, so readOnlyHint=false matches. The idempotent and non-destructive hints are not contradicted. However, the description itself does not surface the important dryRun/confirm gate behavior, though those details exist in the parameter schema.
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 with no filler. It front-loads the action and the resource, and every word contributes to the core 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?
The description is usable for understanding the main operation, and the schema fills in several parameter details. However, it does not explain the confirm/dryRun flow or anything about the returned RCI payload behavior, leaving an agent to infer important operational context.
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?
The description adds useful meaning to the otherwise undocumented parameters by framing the rule as external port to internal IP:port. It partially compensates for the low schema description coverage, but does not clarify the role of proto or wanInterface beyond what the schema already states.
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: creating a port forwarding rule. It specifies the mapping direction from external port to internal IP:port, which is concrete and distinguishes it from list_port_forwards, remove_port_forward, and route-related sibling tools.
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?
The description gives no guidance about when to use this tool, when not to use it, or which alternatives might be more appropriate. It also omits the prerequisite of obtaining a valid WAN interface and does not explain the confirm/dryRun workflow.
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?
No annotations are provided, so the description must carry the behavioral burden. It does include the fact that the source is the DHCP/hotspot table and that it returns a device list with specific fields, which gives some transparency for a read-like operation. However, it does not state whether this is an active snapshot, sorted, or what telemetry/format the output is in – a moderate gap.
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?
A single sentence that leads with the action (‘Список’), the resource (‘устройств’), the source table, and the relevant fields. No filler, no repeated annotation content, and the key scoping information is front-loaded.
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 zero-parameter list tool with no output schema, the description covers the essentials: what is returned (devices), from where (DHCP/hotspot), and the field set (MAC, IP, name, interface). One could argue for more behavior details, but the agent has enough to call the tool correctly and interpret a simple list result.
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 takes no parameters, so the baseline for this dimension is 4. The description compensates by listing the output fields (MAC, IP, name, interface), which adds meaning to what the agent can expect from the result, given that the empty input schema offers no constraint.
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?
‘Список устройств из таблицы DHCP/hotspot’ clearly identifies the resource (devices) and the action (list). It specifies the source table and the returned fields (MAC, IP, name, interface), which makes the purpose unambiguous and distinct from most read-only siblings.
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?
The description states what the tool lists, but does not describe when to use it over alternatives like list_wifi_clients or list_dhcp_reservations. There is no guidance on situation or conditions, no hint that a device list might be the broad view, leaving the agent to infer usage from the name and core directory.
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 indicate a read-write, non-destructive, idempotent operation, and the description adds the key behavioral fact that traffic is sent through an existing VPN interface via policy-based routing. It does not explain behavior on failure, effect on existing routes, or whether the operation only becomes real when confirm=true; the confirm/dryRun semantics are left to the schema.
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 with no filler. It directly explains what the tool does and adds one useful qualifier ('already configured') that helps an agent avoid misuse.
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?
With schema coverage at 100% and annotations covering idempotence and non-destructiveness, the description is adequate for identifying the operation. Still, it does not specify what the agent should do when using dryRun or confirm beyond the schema, nor does it explain the return behavior or the exact relationship with sibling tools like unbind_route_from_vpn. The description is minimal but not misleading.
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 100%, so the input schema already documents network, mask, target, dryRun, and confirm with examples and meanings. The tool description adds only high-level context ('specified network', 'VPN interface') and does not materially improve on the schema's own parameter 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 identifies a specific verb+resource: it directs traffic of a specified network through an already-configured VPN interface. It also names the mechanism (policy-based routing), which clearly distinguishes this tool from generic add_route or unbind_route_from_vpn. The title reinforces the purpose.
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 phrase 'already configured VPN interface' implies the prerequisite that a VPN interface must exist and that this tool is not for VPN setup. However, it does not explicitly state when to prefer bind_route_to_vpn over add_route, nor when to use unbind_route_from_vpn for reversal. The usage context is inferable but not explicitly routed.
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?
No annotations are provided, so the description carries the burden of explaining behavior. It says the tool reports interface state, which is useful, but it does not explicitly state that the operation is read-only, non-destructive, or what the returned state looks like.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Conciseness5/5
Is the description appropriately sized, front-loaded, and free of redundancy?
The description is a single compact sentence that includes the resource type, the full scope of interface categories, and the kind of state returned. There is no filler, repetition, or unnecessary detail.
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 zero-parameter read-only list tool, the description gives enough context to select it: it returns all router interface types and their state. It does not specify an exact output shape, but given no output schema is defined, that is a minor gap rather than a blocking one.
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 takes zero parameters and the schema is already 100% covered. The description does not need to document parameter behavior since there are none to document.
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 identifies the tool's scope: all router network interfaces (WAN, Wi-Fi, VPN, bridges) and their state. This distinguishes it from narrower siblings like get_wan_status or list_vpn_interfaces, though it lacks an explicit verb such as 'returns' or 'retrieves'.
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 word 'all' implies this tool is for a broad interface overview, while siblings like get_wan_status and list_vpn_interfaces cover narrower subsets. However, there is no explicit guidance about when to choose this tool over those alternatives.
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 provide the intent profile (readOnlyHint=false, idempotentHint=true, destructiveHint=false) and the description adds minimal extra behavior: it clarifies that the target is an access point and gives a guest network example. It does not mention side effects like disconnecting clients or how dryRun/confirm work, but those are also present in the parameter descriptions.
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 tool description is a single concise sentence that covers the intent without unnecessary repetition or padding. The inline example is helpful and does not cause unnecessary verbosity.
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 plus the parameter schema and annotations provide enough detail for a simple toggle operation: the main parameter semantics are covered, the mutation profile is clear, and there is no output schema to worry about. Only the usage guidance, which was scored separately, is missing.
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 description adds semantic meaning beyond the bare schema by mapping the boolean `enabled` parameter to action of 'up' or 'down', and by clarifying that the target is a specific access point (interfaceId). Since the schema leaves `enabled` undocumented, this fills an important gap rather than repeating what is already present.
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 clear action ('Поднимает или гасит') and a specific resource ('указанную точку доступа') with an illustrative example (guest network). This directly conveys that the tool toggles a Wi‑Fi access point on or off, and it naturally distinguishes itself from siblings like set_wifi_password or route/port operations.
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?
There is no guidance about when to use this tool versus other settings tools, nor any mention of prerequisites or exclusions. The only hint about the interfaceId comes from the schema, not the description, so an agent must discover usage context from elsewhere.
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 mark the tool as destructive and non-read-only. The description adds important context beyond the annotations: the server-config prerequisite, that the RCI request format has not been validated against a live device in this project, and that dryRun plus user confirmation should precede real use.
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?
Three short sentences, each carrying distinct information: the action, the configuration prerequisite, and the safety caveat. Nothing is redundant with the title or the schema, and the most important behavioral risk is disclosed early.
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 destructive two-parameter tool with no output schema, the description covers the prerequisite, the safety workflow, and the uncertainty about the RCI payload. It does not detail the exact response for a real reboot, but that is a minor gap given the schema already explains the dryRun return value.
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?
The schema already documents both boolean parameters in full, including dryRun returning an RCI payload and confirm being required for a real change. Since schema coverage is 100%, the description adds little strictly parameter-level information beyond recommending an invocation order, so the baseline score of 3 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 opens with a clear, specific statement: 'Немедленная перезагрузка роутера.' It identifies both the action (reboot) and the resource (router), and this operation is distinct from all sibling tools, which are mostly read-only queries or configuration setters.
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 usage conditions: it requires ALLOW_DESTRUCTIVE=true, recommends running dryRun first, and requires explicit user confirmation before the first real use. It does not explicitly say when not to use it, but the safety guidance effectively tells the agent how to gate invocation.
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 several important behaviors beyond the annotations: the file is not executed by a system interpreter, only a whitelisted grammar is parsed, any unrecognized line fails the whole batch before application, and dryRun returns RCI payloads without sending them. This is especially valuable because the annotations only say the operation is not read-only; the description clarifies the actual safety and failure semantics.
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: it states the primary action first, then the security/failure model, then the dryRun behavior. Each sentence provides distinct useful information without repetition or fluff.
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 a mutating batch operation with no output schema, and the description covers key context: supported grammar, fail-closed behavior, and dry-run semantics. The only noticeable gap is that the normal (non-dryRun) return/result shape is not described at all, so an agent is left to infer what happens after successful application beyond the act itself.
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 100%, so the baseline is 3 and the description is not required to compensate. The description adds a small nuance by explaining that dryRun returns 'all RCI payloads', but the parameter meanings for filePath and confirm are sufficiently covered by the schema and not expanded further in 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: 'Читает .bat-файл, разбирает его ограниченной грамматикой... и применяет построчно'. It names the supported grammar (ROUTE ADD/DELETE, VPN BIND/UNBIND), which differentiates it from single-route sibling tools. The batch-oriented scope is explicit and 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 makes it clear that this is a batch file processor, so the typical use case is implied. However, it does not explicitly state when an agent should choose this over the single-route siblings like add_route or remove_route, nor does it provide any when-not-to-use guidance. Usage is therefore inferred rather than explicitly routed.
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?
No annotations are provided, so the description carries transparency responsibility. It goes beyond the title by disclosing an important reliability caveat: WireGuard filtering is live-verified, while OpenVPN/IKEv2/L2TP/PPTP/VLESS filtering is only type-based and not verified on a real router. This is highly useful. A minor gap is the lack of explicit statement about what fields the list returns.
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 cover the core purpose, the exact filtering scope, a reliability warning, and the practical use case. There is no filler, and the highest-value information is front-loaded.
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 zero-parameter read-only tool with no output schema, the description is largely complete: it explains what is returned, which tunnel types are trusted, and why an agent would call it. It could add a little more detail about the output values needed by bind_route_to_vpn, but that is a minor gap given the low complexity.
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 already reflects that fully. With 100% schema coverage and no parameters to document, the baseline 4 applies and no description compensation 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 identifies the tool as returning a filtered list of router interfaces limited to VPN tunnels, making its purpose concrete and distinct from the generic sibling get_interfaces. It also names the typical next step (bind_route_to_vpn), reinforcing the tool's role.
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 says to use this tool for binding routes to VPN tunnels and scopes it to only VPN interfaces. It does not explicitly contrast it with get_interfaces for non-VPN interfaces, but the exclusion is strongly implied by 'only VPN tunnels'.
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 annotations already communicate that this is a read-only, idempotent operation, but the description adds substantial behavioral value: it documents the admin-account requirement, the exact 'execute denied' error, the fact that this is an RCI limitation rather than a tool bug, and the agent's required response. This is exactly the kind of context an agent cannot infer from the schema.
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 core purpose is front-loaded first, and every subsequent sentence justifies its place: the admin requirement, the observed failure mode, the cause, and the do-not-or workaround instruction. It is detailed but not verbose.
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 parameter-free, read-only tool, this is nearly complete: an agent knows what is checked, what credential privileges are needed, and what to do when the router rejects the call. The only minor gap is that the exact return value or update payload is not described, and there is no output schema to carry that information.
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 input schema has full coverage, so there is no parameter-specific meaning for the description to add. The description does provide helpful operational context about the configured update channel and admin credentials in the MCP server config, but since there are no parameters, it stays at the 0-parameter baseline of 4.
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 very specific action: check whether a new KeeneticOS version is available through the router's component manager in the configured update channel. This is clearly distinguishable from sibling read-only tools such as get_version, which reports the installed version rather than update availability.
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 normal use context is clear — check for a firmware update availability — and the failure-handling guidance is explicit: on 'execute denied', tell the user to configure an admin account and do not try to bypass the restriction. It does not explicitly mention alternative tools or when not to use it, which prevents a 5.
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?
Annotations only convey readOnly/idempotent/non-destructive; the description goes well beyond them by disclosing the critical trait: the result contains plaintext or weakly obfuscated secrets—password hashes, WPA-PSK, and WireGuard parameters. It also instructs the agent on safe downstream handling (not quoting secrets, writing backups to a file outside git), which is exactly the context an AI agent needs 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 longer than average, but every sentence earns its place: primary purpose is front-loaded, the web-UI equivalence adds precision, the 'ВАЖНО' section flags the security risk, and the final guidance prescribes concrete safe handling. Nothing is redundant or padded.
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?
With no output schema, the description correctly bears the burden of explaining the return value—full running-config as CLI text—and thoroughly covers sensitivity and storage handling. The only minor gaps are a lack of any note about the output potentially being very large or truncated, which is a small omission for a zero-parameter read-only 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 and 100% schema description coverage, so the schema itself fully defines the parameter surface. Per the baseline for 0-parameter tools, the description does not need to compensate; it additionally implies that no configuration is needed, which matches 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 states a precise verb ('Возвращает'), a specific resource ('полный running-config роутера'), and the output format (текст в CLI-синтаксисе). The reference to the web-UI Save button clarifies exactly what the tool returns and distinguishes it from the read-only sibling tools like get_version and get_system_info, which return only fragments of device state.
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 establishes the use context: this is the config-backup/export tool, equivalent to the Save button, and it gives explicit operational conditions—warn the user before invoking and store results outside a git repository when a backup is requested. It stops short of naming alternatives or explicit when-not-to-use scenarios relative to siblings, so it earns 4 rather than 5.
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:

[![Keenetic-router-plugin MCP server](https://glama.ai/mcp/servers/Kykyryky23/Keenetic-router-plugin/badges/card.svg)](https://glama.ai/mcp/servers/Kykyryky23/Keenetic-router-plugin)

Score Badge

Copy to your README.md:

[![Keenetic-router-plugin MCP server](https://glama.ai/mcp/servers/Kykyryky23/Keenetic-router-plugin/badges/score.svg)](https://glama.ai/mcp/servers/Kykyryky23/Keenetic-router-plugin)

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/Kykyryky23/Keenetic-router-plugin'

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