mcp-jumpserver-gui-sucks

Server Quality Checklist

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

Latest release: v0.4.0
Disambiguation4/5
Each tool targets a specific operation within distinct domains (asset discovery, connection tokens, terminal sessions, SFTP). While similar pairs like jms_probe_koko_terminal and jms_acquire_terminal_session exist, their descriptions clearly differentiate the scope. Overall, tools are easy to distinguish.
Naming Consistency5/5
All tools share the jms_ prefix and follow a consistent verb_noun pattern for actions (list, get, create, expire, upload, etc.). Informational tools use noun-only names, but this is a minor deviation that does not break the overall consistency.
Tool Count2/5
With 34 tools, this server is significantly larger than typical MCP servers and exceeds the 25-tool threshold for 'too many'. Several utilities, such as jms_paths, jms_status, and the usage guides, could be consolidated, making the tool surface feel excessive for the core purpose.
Completeness5/5
The tool set provides comprehensive coverage of the JumpServer remote access workflow, including asset discovery, connection token lifecycle, terminal session management, and SFTP operations. No obvious missing operations for the intended use case.
Average 3.4/5 across 34 of 34 tools scored. Lowest: 2.7/5.
See the Tool Scores section below for per-tool breakdowns.
- No community issues in the last 6 months
- 7 commits in the last 12 weeks
- Last stable release on August 13, 2026
- 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

Behavior2/5
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
No annotations are present, so the description must fully disclose behavior, but it only states the action and account resolution input. It does not mention token lifetime, reusability effects, permission requirements, or side effects of creation.
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 wasted words. However, it is somewhat under-sized for a tool with five parameters and no schema descriptions, so it is concise but not as well-structured for agent comprehension as it could be.
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 creation tool with five parameters, no annotations, and no schema descriptions, this description is insufficient. It does not explain how this token will be used, how reusable or connect_method affect behavior, or what the output schema contains, leaving significant gaps for the 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?
Schema description coverage is 0%, so the description must compensate for all parameter meaning. It clarifies 'account' accepts either a concrete ID or user-facing reference, but leaves asset_id, protocol, reusable, and connect_method completely unexplained.
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 action verb ('Create') and identifies the resource ('connection token'). It also specifies the key input choices ('concrete account ID or user-facing account reference'), which helps distinguish this from sibling list/expire token tools, though it does not explain what a connection token is for.
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 create a connection token versus using alternatives like list_connection_tokens or expire_connection_token. There are no prerequisites, context hints, or exclusions to help the agent choose this tool correctly.
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 provided, the description carries the full burden of behavioral disclosure. It fails to state whether the probe is read-only, whether it establishes an actual connection, or what side effects (if any) it may have. 'Probe' implies a non-destructive check, but this is not explicit, and no details about auth requirements, timeouts, or failure modes are given.
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 sentence that is direct and waste-free. It front-loads the action and resource, making it easy to grasp quickly. However, given the tool's complexity, additional detail might be necessary, but the description itself is concise and well structured for what it includes.
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 7 parameters and an output schema, but the description is too sparse to be complete. It does not explain parameter semantics, usage context, or behavioral nuances. While the output schema may document return values, the description alone is insufficient for an agent to correctly select and invoke this tool among 30+ siblings with similar terminal-related functions.
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 covers seven parameters with zero description coverage, so the description must compensate. It does add minimal meaning by mentioning 'concrete account ID or a user-facing account reference', which likely maps to the 'account' parameter, but it does not clarify the other six parameters (e.g., cols, rows, protocol, max_messages, connect_method) or the required 'asset_id'. This is insufficient for a 7-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?
The description uses a specific verb 'Probe' and identifies the resource as 'KoKo terminal access', which clearly states the tool's core function. It also mentions the two ways to specify the target (concrete account ID or user-facing account reference), adding relevant detail. However, it does not explicitly differentiate from similar sibling tools like jms_resolve_terminal_target, though the term 'probe' suggests a distinct non-invasive check.
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. It does not state whether it should be used before acquiring a terminal session, how it relates to jms_resolve_terminal_target, or any exclusions. The only implied context is that it is a probing action, but no explicit when-to-use or when-not-to-use information is provided.
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 provided, the description carries full responsibility for behavioral disclosure. It states 'List' which implies read-only, but it doesn't mention permissions, error handling, path validation, or what the output contains. The description adds minimal behavioral context beyond the action itself.
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 with no wasted words. It is front-loaded with the primary action. However, it is so brief that it borders on under-specification, though for a simple list operation it is still efficient.
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?
Given the tool's placement among many SFTP session management siblings, the description lacks critical context such as requiring an active session, how to obtain one, or what the output format is (though an output schema exists). It is not complete enough for an agent to confidently invoke it in a real workflow.
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 does not explain 'path' or 'session_handle' at all. While parameter names are somewhat self-explanatory, 'session_handle' requires context about acquiring an SFTP session, which is missing.
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 'List one absolute remote directory path' clearly states the action (list) and the resource (a remote directory path). It specifies absolute and remote, which adds precision. However, it does not explicitly say 'contents' or differentiate itself from sibling tools like jms_sftp_stat, though 'list' vs 'stat' is a natural distinction.
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. It doesn't mention that it requires an active SFTP session or how it relates to sibling tools like jms_sftp_stat or jms_sftp_mkdir. The description provides no context for selection.
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, the description must carry the behavioral disclosure burden. It hints at 'reuse' and 'managed' but does not explain session lifecycle, side effects, authentication needs, or what happens if no session exists. This is minimal for a session-acquisition 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?
The description is a single concise sentence with no redundant phrases. It efficiently communicates the core action and resource, earning its place without wasted words.
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 session management tool with no annotations and sparse parameters, the description is too terse. It does not address session reuse conditions, required inputs, or output behavior, although an output schema exists. The absence of context makes it incomplete for safe and correct usage.
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 has 0% description coverage and two parameters. The phrase 'Resolve a target' gives a hint about asset_ref, but account_ref is not mentioned at all. The description fails to compensate for the lack of schema descriptions, leaving parameter meanings ambiguous.
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 ('Resolve', 'get or reuse') and identifies a clear resource ('managed KoKo SFTP session'), distinguishing it from sibling tools like jms_acquire_terminal_session. It clearly indicates this is for SFTP session acquisition rather than other 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?
The description gives no explicit guidance on when to use this tool versus alternatives. It implies usage for obtaining an SFTP session but does not mention related tools (e.g., jms_acquire_terminal_session) or any exclusions or prerequisites.
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, the description carries the full burden. It discloses only that the tool interrupts a running command, but omits key behaviors such as sending a signal (default ctrl_c), timeout handling, or that the session itself remains active. This is insufficient for a mutating operation.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Conciseness3/5
Is the description appropriately sized, front-loaded, and free of redundancy?
The single sentence is efficient and front-loaded, but it is under-specified. While brevity is good, the description omits essential detail that should accompany the tool, making it more under-sized than appropriately concise.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Completeness1/5
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
The tool has 4 parameters and an output schema, but the description provides only a high-level statement. It lacks parameter explanations, behavioral context, and any guidance on expected outcomes or errors. This is inadequate for a tool with this complexity.
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?
Schema description coverage is 0% and the description provides no explanation for any of the four parameters. The agent is left without insight into what 'signal' options exist, what 'session_handle' refers to, or the purpose of the timeout 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 action ('Interrupt') and the target ('a running command in a managed KoKo terminal session'). This specific verb+resource combination distinguishes it from sibling tools like jms_run_terminal_command or jms_close_terminal_session.
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 use when a command is running and needs interruption, but it does not explicitly state when to use this tool versus alternatives like sending input or closing the session. No exclusions or alternative recommendations are provided.
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. It does not state whether the operation is read-only, whether it requires specific permissions, or whether it performs network calls. The word 'resolve' implies a lookup with no side effects, but this is not explicit. There is no mention of potential failures or behavior for invalid references.
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 is front-loaded with the core action. No wasted words, and it immediately communicates the tool's purpose. It is appropriately concise for a simple resolution utility.
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?
Given the tool's simplicity and the presence of an output schema, the description need not detail return values. However, it lacks context about the tool's role in the terminal workflow (e.g., that it should be used before acquiring sessions), and it does not mention edge cases or required preconditions. The description is minimal and leaves the agent to infer integration points with sibling tools.
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 refers to 'user-facing asset and account references,' which maps loosely to asset_ref and account_ref, but it does not explain the format of these references, the meaning of protocol, or how defaults work. It adds minimal semantic value beyond what a user might infer from parameter names.
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 a specific purpose: resolving user-facing references into concrete IDs. It uses an active verb ('resolve') and identifies the resources (asset and account references). However, it does not explicitly differentiate from sibling tools like jms_list_assets or jms_get_asset, though the resolver role is distinct enough to infer.
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. The description does not mention that this should be called before terminal session acquisition or that it complements other lookup tools. The phrase 'needed by terminal entrypoints' hints at usage, but there is no explicit when-to-use or when-not-to-use direction.
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 provided, the description carries the full burden of behavioral disclosure. It does not mention whether the command execution may have side effects, whether it blocks, how timeouts work, or what happens to the shell session. The description only names the operation without explaining its behavior.
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 wasted words. However, it is almost too terse, omitting required context that would help in safe invocation, so it earns slightly below top marks.
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 command execution tool that can have side effects and includes timeout parameters and an output schema, the description is far too thin. It omits prerequisites, return behavior, and timeout semantics, making it inadequate for safe and correct use.
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?
Schema description coverage is 0% for all 4 parameters, and the description does not compensate. It mentions 'one command' and 'already acquired' but fails to explain session_handle, command, or the two timeout parameters, leaving the agent to guess their meaning.
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 (Run), the resource (one command), and the context (already acquired managed KoKo shell). This distinguishes it from sibling tools like jms_acquire_terminal_session (session acquisition) and jms_read_terminal_output (reading output).
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 versus alternatives such as jms_send_terminal_input or jms_acquire_terminal_session. The phrase 'already acquired' implies a prerequisite but does not exclude or recommend any other tools.
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, the description carries the full burden of behavioral disclosure. It only says 'send raw input' and does not explain effects on the session, whether the operation blocks, how the input is interpreted, or any side effects. This is comparable to the update_drive example which also lacked 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 sentence with no waste. It is front-loaded with the core action and target, making it very concise.
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?
Despite having an output schema, the description lacks essential context such as session prerequisites, how to obtain a session_handle, behavior of append_newline, and interaction with the terminal lifecycle. For a tool with three parameters and no annotations, this is insufficient.
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 compensate by explaining any of the three parameters: session_handle, data, or append_newline. The verb 'send' hints at 'data' being the input, but no details are given for the other parameters, leaving the agent to guess.
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 ('Send raw input') and the target resource ('managed KoKo terminal session'), making the primary purpose evident. It implies differentiation from siblings like jms_run_terminal_command via the word 'raw', but it does not explicitly distinguish between them.
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 jms_run_terminal_command, jms_read_terminal_output, or jms_interrupt_terminal_session. The description does not mention prerequisites, use cases, 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?
With no annotations, the description must carry behavioral transparency but only says 'expire explicitly'. It does not disclose side effects, idempotency, error behavior, or impact on active sessions, leaving critical information missing.
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 clear sentence with no wasted words, front-loading the action and resource effectively. It is appropriately sized for a simple tool, though it lacks detail.
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?
Despite having an output schema, the description omits essential context about side effects and behavior. For a mutating tool with simple parameters, the lack of detail about consequences makes it incomplete for safe invocation.
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?
Schema description coverage is 0%, and the description mentions no parameters. The only parameter, token_id, is left entirely unexplained, so the agent has no guidance on its format, source, or meaning.
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 'expire' and identifies the resource 'connection token', clearly distinguishing it from sibling tools like list/create/refresh tokens. The action is unambiguous.
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 versus alternatives. For instance, it doesn't mention whether tokens auto-expire or when manual expiration is appropriate. The description provides no context beyond the basic action.
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. It implies a read-only operation through 'Summarize' but does not explicitly state non-destructive behavior, auth requirements, or any side effects. This is minimal disclosure for a tool without annotations.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Conciseness4/5
Is the description appropriately sized, front-loaded, and free of redundancy?
The description is a single, front-loaded sentence with no filler. It communicates the core action and subject clearly. It earns its place, though it could be expanded with usage context.
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 a simple 1-param schema and an output schema, but the description lacks usage guidelines and explicit behavioral transparency. Without annotations, the description is too sparse to fully inform an agent when to invoke this tool versus related siblings. The absence of any 'when to use' language is a significant gap.
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 only parameter, asset_id, is not described in the schema (0% coverage). The description references 'one asset,' which implies asset_id identifies that asset, but it doesn't explicitly define the parameter's format or usage. Since it's a single, self-explanatory parameter, the contextual compensation is borderline adequate.
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 the specific verb 'Summarize' and identifies the resource ('accounts, protocols, and connect methods') for 'one asset'. This distinguishes it from sibling tools like jms_list_connect_methods (which lists methods globally) and jms_get_asset (which likely gets asset details). However, 'summarize' is somewhat vague about the exact output format.
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 versus alternatives. The description doesn't mention exclusions, prerequisites, or when to prefer jms_get_asset or jms_list_connect_methods. It simply states what it does, leaving the agent to infer usage context.
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, the description must fully disclose behavior. It mentions 'until idle or timeout,' which indicates blocking behavior, and 'Read' implies non-mutating intent. However, it does not explain whether reading consumes the buffer, how after_seq affects output, or whether a valid session is required, leaving important behavioral details undisclosed.
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. Every word contributes to meaning, exactly conveying the core action and condition. It is appropriately concise for a simple read operation.
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?
Given the tool has 4 parameters, no annotations, and an output schema, the description is too sparse. It does not explain the session lifecycle, the meaning of after_seq, or how this tool fits into the overall terminal session flow (e.g., after acquire and send). The output schema may cover return values, but parameter semantics and operational context remain incomplete.
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?
Schema description coverage is 0%, and the description provides no parameter details. While parameter names like idle_timeout_seconds and total_timeout_seconds are somewhat self-explanatory, the critical after_seq parameter is entirely unexplained, making correct invocation difficult.
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 ('Read') and clearly identifies the resource ('buffered output from a managed KoKo terminal session'), with an additional condition ('until idle or timeout') that clarifies scope. It is distinguishable from sibling tools like send_terminal_input or close_terminal_session, which perform different actions.
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 explicit guidance is provided on when to use this tool versus alternatives, such as jms_run_terminal_command or jms_probe_koko_terminal. The description implies usage when you need to read output from an existing session, but it does not state prerequisites, exclusions, or alternative tools.
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, the description carries full responsibility for behavioral disclosure. It only says 'resize,' which is a mutation, but does not describe effects, reversibility, session requirements, or whether it returns success/failure. This is a significant gap for a tool that alters an existing session.
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, tightly worded sentence. It is front-loaded with the verb 'resize' and wastes no words, making it easy to parse and directly informative.
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 tool, the description is minimally sufficient but lacks important contextual details like preconditions or behavioral notes. Since an output schema exists, return values may be covered there, but the description alone is thin given the absence of annotations and parameter descriptions.
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 elaborate on any parameters. While the parameter names (session_handle, cols, rows) are intuitive, the description fails to provide additional meaning or context, such as valid ranges or format details.
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 ('resize') and identifies a clear resource ('managed KoKo terminal session'), which distinguishes it from sibling terminal session tools like send_input or close_terminal_session. However, it does not explicitly mention the dimension parameters (cols, rows), though these are present in the schema.
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. There is no mention of prerequisites (e.g., an active session) or scenarios where resizing is appropriate. The description simply states what it does without any conditional context.
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, the description carries full burden. It discloses a key behavior ('get or reuse') but omits critical context such as authentication requirements, what 'managed' implies, error behaviors, or side effects. This is insufficient for a tool that starts a session.
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, efficient sentence that front-loads the action and resource. Every word contributes meaning with no redundancy or filler.
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?
Given the tool has 7 parameters, no annotations, and an output schema, the description is too minimal. It omits parameter semantics and behavioral details like reuse conditions and startup timeouts, leaving significant gaps 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.
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 only references 'asset/account pair' (covering asset_ref and account_ref), but leaves cols, rows, protocol, connect_method, and startup_idle_timeout_seconds unexplained. This fails to compensate for the missing schema descriptions.
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 action (resolve and acquire/reuse) and the resource (managed KoKo shell for asset/account pair). It distinguishes from sibling jms_acquire_sftp_session by specifying 'KoKo shell' and 'asset/account pair', though the term 'KoKo shell' may require domain knowledge.
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 a terminal shell for an asset/account pair is needed. However, it does not explicitly mention alternatives (e.g., jms_run_terminal_command for direct commands, jms_list_terminal_sessions for listing) or when not to use it, leaving the decision to the agent.
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, the description must carry the behavioral burden. The 'observed perms endpoint' hint suggests a permissions-aware listing, which is a useful behavioral trait, but the description is silent on pagination, filtering, defaults, and output structure.
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 single-sentence description is concise and front-loaded with the key verb 'List'. It has zero waste, but the brevity comes at the cost of missing critical context, so it's not a perfect score.
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?
Given 4 undocumented parameters, no annotations, and an output schema, the description is far too sparse. It fails to explain return values, filtering semantics, or the endpoint's quirks, making it incomplete for an agent to confidently invoke.
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?
Schema description coverage is 0%, yet the description does not mention any of the four parameters (node, asset, limit, offset). The parameter names alone are insufficient, especially 'node' and 'asset' which could be filters or selectors, leaving the agent without added meaning.
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 'List assets', a clear verb+resource pair that immediately states the primary function. The phrase 'used by the current GUI' gives contextual provenance, and the plural 'assets' distinguishes it from sibling tools like jms_get_asset and jms_list_nodes.
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 explicit guidance is provided on when to use this tool versus alternatives. The only contextual hint is 'used by the current GUI', which weakly implies GUI parity but does not mention when to prefer this over jms_get_asset or jms_list_nodes.
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, the description carries the full burden of behavioral disclosure. It does disclose that the token secret is not exposed, which is meaningful. However, it omits other useful behavioral traits such as read-only safety, pagination behavior, or authorization 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, well-structured sentence that immediately states the core action and a critical constraint. No wasted words, and the key information 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?
The tool is simple and has an output schema, but the description lacks parameter semantics, usage guidance, and an explicit safety profile in the absence of annotations. This is insufficient for an agent to fully understand how and when to invoke the tool.
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?
Schema description coverage is 0%, so the description must compensate. It does not mention the limit or offset parameters at all, leaving their semantics entirely undocumented. The defaults exist in the schema but the description adds no value for parameter understanding.
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 ('List'), a specific resource ('active connection tokens'), and a key distinction ('without exposing the token secret value'). This unambiguously differentiates it from sibling tools like create or expire.
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 versus alternatives. While the siblings 'create' and 'expire' imply different actions, the description does not explicitly state when listing is appropriate or mention any 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?
No annotations are provided, so the description carries the full burden. It discloses one behavioral aspect (optional parent creation) but does not mention behaviors like error handling when the directory exists, permissions, or side effects. For a mutation tool without annotations, this is a significant 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?
The description is one concise sentence with no fluff. It front-loads the core action and includes the key optional behavior. It is appropriately sized for the tool's apparent simplicity.
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?
Given the presence of an output schema, return values are covered, but the description still lacks essential context such as prerequisites for use, handling of existing directories, and parameter semantics. With three parameters and zero schema description coverage, the description is too sparse to be considered 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 compensate. It only hints at the 'parents' boolean via 'optionally creating missing parents' but does not clarify the meaning of 'path' (e.g., relative vs absolute) or 'session_handle' (e.g., how to obtain it). The description adds minimal value beyond the bare 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 specific action ('Create a remote directory') with a clear resource target and an optional behavior (creating missing parents). It clearly distinguishes from sibling tools like jms_sftp_list or jms_sftp_delete, as no other tool creates directories.
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 vs alternatives, prerequisites (e.g., needing an active SFTP session), or situations where mkdir would be inappropriate. The single sentence does not provide any context for decision-making.
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 must carry the full burden of behavioral disclosure. It mentions 'observed perms endpoint' but does not clarify whether this is read-only, what response format to expect, or any error/edge-case behavior. This is minimal disclosure for a tool with no annotation support.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Conciseness3/5
Is the description appropriately sized, front-loaded, and free of redundancy?
The description is a single short sentence, but the phrase 'through the observed perms endpoint' is vague and arguably unnecessary. It does not add actionable value and could confuse the agent, so while concise in length, it is not optimally structured for clarity.
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 one-parameter fetch tool with an output schema, the description is minimally adequate. However, it lacks guidance on how asset_id relates to sibling tools and gives no behavioral context. The odd 'observed perms endpoint' phrasing further detracts from completeness, making this a borderline viable but not rich description.
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 0% description coverage for the sole parameter asset_id, and the description does not explain it or add meaning beyond the parameter name. While 'asset_id' is somewhat self-explanatory, the description fails to mention that this ID should be obtained from jms_list_assets or similar, leaving a semantic gap.
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 'Fetch one asset detail', using a specific verb and resource. It distinguishes itself from sibling tools like jms_list_assets (list all) and jms_get_asset_access (access details). The phrase 'through the observed perms endpoint' is odd but does not obscure the core 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 description implies usage for fetching a single asset by ID, but it does not explicitly state when to use this versus alternatives like jms_list_assets or jms_get_asset_access. No explicit exclusions or alternative tool mentions are provided, leaving usage guidance mostly implicit.
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 full burden of behavioral disclosure. It discloses the exit action and verification step, which implies mutation (state change) of the session. However, it does not state whether the operation is destructive or reversible, what happens if verification fails, or if any rate limits or auth constraints apply. The description adds some value beyond the schema but leaves significant gaps.
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 captures the core action. It is front-loaded with the primary operation and includes the verification step. While not verbose, it could be more efficient by also hinting at the parameters. However, for its brevity, it communicates the essential purpose 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?
Given the complexity (3 parameters, 1 required) and the presence of an output schema, the description is moderately complete. It explains what the tool does and mentions verification, but fails to cover parameter semantics, preconditions, or behavior on failure. The output schema may explain return values, but the description still lacks key usage and behavioral details. It is adequate but not thorough.
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 schema coverage is 0%, so the description must compensate. The description mentions 'exit one MCP-managed user shell' and 'verification,' which gives context for the session_handle parameter (identifies the shell), but does not explicitly describe the timeout parameters or their roles. With 3 parameters and no schema descriptions, the description partially compensates but could do more to explain the purpose of total_timeout_seconds and settle_timeout_seconds.
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: 'Exit one MCP-managed user shell and verify restoration of the previous user.' This includes a specific verb (exit), resource (MCP-managed user shell), and an additional verification step. It distinguishes itself from similar tools by mentioning 'exit' and 'restoration of previous user,' which differentiates it from other terminal operations like switch, interrupt, or close.
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 does not provide any guidance on when to use this tool versus alternatives. It lacks context about prerequisites (e.g., a session must be switched to a different user first), when to prefer this over close or interrupt, or what happens if the tool is called without a switched user. No explicit when-to-use or when-not-to-use information is given.
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 full burden of behavioral disclosure. It states the tool returns the effective OS user, which implies a read-only operation, but does not mention if it requires any special permissions or authentication state, nor what happens if the session is invalid. The description is adequate but lacks depth.
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 immediately conveys the tool's primary function. No extraneous words or repetitive information.
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 has an output schema and a single required parameter, the description provides the core purpose, making it minimally adequate. However, the complete omission of parameter semantics and usage guidance leaves gaps for an AI agent to fully understand all invocation details.
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 the three parameters (session_handle, total_timeout_seconds, settle_timeout_seconds). The description does not mention any parameters at all, leaving the agent to infer their meaning from the schema titles and defaults. This is insufficient, especially for timeout parameters whose purpose is non-obvious.
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 the verb 'verify and return' with the specific resource 'effective operating-system user in a managed shell', which clearly indicates what the tool does. However, it does not explicitly distinguish this from siblings like jms_switch_terminal_user or jms_exit_terminal_user, which also deal with user identity.
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 this is used to check the current OS user after shell operations, but provides no explicit guidance on when to use it versus alternatives like jms_switch_terminal_user or jms_exit_terminal_user. No exclusions or context about prerequisites like requiring an active session are mentioned.
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, the description discloses the conditional behavior of refreshing if valid or reporting re-login. However, it does not explain side effects, what 'refresh' actually does, or how the force parameter alters behavior, which leaves ambiguity.
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 conveys the primary behavior. It is well-structured and wastes no words, though it is slightly under-specified in other dimensions.
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 behavior but omits crucial guidance on the force parameter and how this tool fits within the terminal authentication workflow. The presence of an output schema reduces the need to explain return values, but the overall description remains minimal for a tool with a parameter.
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 one boolean parameter 'force' with zero description coverage, and the tool description does not mention this parameter at all. Since the description must compensate for the missing schema details and fails to do so, the parameter semantics are poorly communicated.
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 refreshes a persisted cookie-backed terminal session and reports re-login if invalid. It uses a specific verb and resource, but it does not explicitly distinguish this from sibling tools like jms_acquire_terminal_session.
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 this tool is for refreshing an existing session, but it does not explicitly state when to use it versus acquiring a new session or provide any exclusion criteria. No alternatives are mentioned, leaving usage context vague.
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 provided, the description carries full responsibility for disclosing destructive behavior. It only mentions the recursive requirement for directories, but fails to explain the confirm parameter, irreversibility, permissions, or what happens on errors, which are critical for a delete 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 wasted words. While it is concise, it omits important parameter and safety details, so it is efficient but incomplete.
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?
Given the delete operation has 4 parameters, no annotations, and 0% schema description coverage, the description is far too sparse. It does not address the confirm flag, expected output, error scenarios, or session requirements, leaving significant 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?
Schema description coverage is 0%, so the description must compensate. It explains recursive, but the confirm parameter—likely crucial for confirming a destructive operation—is not mentioned, and path and session_handle are only implied by name.
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: delete an approved path, with the specific recursive behavior for directories. This distinguishes it from sibling SFTP tools like list, stat, mkdir, upload, and download.
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?
It provides a clear context for use by stating that directories require recursive=true. However, it does not explicitly indicate when not to use this tool or mention alternative tools for non-delete operations.
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, the description carries the full burden. It implies a read-only operation via 'Show', but does not explicitly state that it has no side effects or mention any authentication/permission requirements. For a zero-parameter introspection tool, this is adequate but minimal.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
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 is appropriately sized for a tool with no parameters and a straightforward purpose.
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?
Despite the cryptic mention of 'runtime environment keys' and 'resolved state paths', the tool has zero parameters and an output schema exists to clarify return values. The description provides a concise, sufficient overview for such a simple 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 no parameters, so there is nothing to misinterpret. The description adds no parameter information, but this is irrelevant given the empty schema. A baseline score of 4 is appropriate for zero-parameter tools.
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 ('Show') and its resource ('runtime environment keys and resolved state paths'). It does not differentiate from sibling tools like jms_status or jms_profile, but the purpose is specific and understandable.
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. The description only states what it does, with no context about typical scenarios, prerequisites, or why a user might choose it over related diagnostics tools.
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 full transparency burden. It discloses the key overwrite behavior ('replacing a local file requires overwrite=true'), but omits other important traits like error handling, permission requirements, or partial-download behavior, leaving the agent under-informed.
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 a clear verb and a necessary caveat. Every word contributes, and there is no filler or redundant repetition of schema details.
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?
Although the tool is relatively simple and an output schema exists, the description lacks session context and only partially covers behavioral details. It is minimally viable but does not fully round out the operational picture for an agent selecting the 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?
The schema has 0% parameter descriptions, so the description must compensate. It adds meaning by mapping 'remote file' to remote_path, 'local file' to local_path, and overwrite to replacement logic, but it leaves session_handle entirely unexplained and does not specify path formats or defaults beyond overwrite's existence.
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 explicitly states 'Download a remote file' with a specific verb and resource, which clearly distinguishes this tool from sibling SFTP operations like upload, list, and delete. The overwrite caveat further clarifies its scope.
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, no mention of prerequisites such as an active SFTP session from jms_acquire_sftp_session, and no exclusions. The overwrite note is a behavioral condition, not usage guidance.
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 exist, so the description bears the full burden. 'Probe' suggests a read-only operation, but it does not disclose potential side effects, required permissions, or what 'local auth state' entails, leaving behavioral expectations under-specified.
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, front-loaded sentence conveys the tool's purpose with no wasted words.
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 the tool's zero-parameter complexity and the presence of an output schema, the description provides a sufficient overview. However, it omits any explicit statement of read-only behavior or typical use cases, which slightly reduces completeness.
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 information to supplement. The schema trivially covers 100% of parameters, and the description adds no parameter detail because none is 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 uses the verb 'probe' with the resource 'local auth state and the current JumpServer session,' clearly stating the tool's function. It is distinct from siblings like jms_profile or jms_refresh_terminal_auth, though it doesn't explicitly name alternatives, so slightly less clear than the gold standard.
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?
No explicit when-to-use or alternative guidance is provided. The description implies usage for checking authentication status and session state, which is an inferred context rather than an explicit directive.
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, the description carries the burden of behavioral disclosure. It adds the 'without overwriting' constraint, which is valuable, but does not disclose other behavioral traits such as behavior when the target exists (error vs. no-op), permission requirements, or support for directories.
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 concise and front-loaded, with no wasted words. It effectively communicates the core purpose and a key constraint.
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 rename operation, the description is adequate but not fully complete. It does not mention whether it works on files and directories, nor what happens if the target already exists. The existence of an output schema mitigates the need to describe return values, but more operational context would improve completeness.
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 elaborate on the parameters. While 'path' and 'new_name' are somewhat self-explanatory, 'session_handle' is not mentioned, and no additional meaning is added 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 clearly states the action ('Rename'), the resource ('remote entry'), and a key constraint ('without overwriting an existing sibling'). It distinguishes itself from sibling operations like delete, upload, and download.
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 renaming remote entries but does not explicitly state when to prefer this over alternatives or provide exclusion criteria. The context of sibling tools makes the purpose evident, but no direct guidance is given.
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, the description carries the burden of behavioral disclosure. It discloses the key overwrite behavior, which is useful, but it stops short of explaining what happens when overwrite is false (error, skip, etc.), or other side effects like directory creation or authentication requirements. The disclosure is partial, earning a 3.
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 with no filler words. It front-loads the action and includes the essential caveat. This is an example of efficient writing that earns its place without redundancy.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Completeness1/5
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
Given 4 parameters, no annotations, and the presence of an output schema, the description is far too thin. It does not explain prerequisites like session_handle, path semantics, or error scenarios. The one-line description is not enough to understand the tool's full context, especially when compared to sibling tools that require session management.
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 local_path and remote_path via 'local file' and 'remote file' and mentions overwrite, but it fails to clarify session_handle, path formats, or the exact meaning of overwrite beyond the schema's default. The compensation is inadequate for a 4-parameter tool.
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 verb and resource: 'Upload a local file.' This distinctly separates it from sibling tools like jms_sftp_download, jms_sftp_rename, and jms_sftp_delete. The overwrite condition adds specificity without diluting the core 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 overwrite requirement ('replacing a remote file requires overwrite=true') provides clear context for a common use case and a critical constraint. It does not explicitly compare to alternatives, but the purpose itself is self-evident against the sibling list, so the guidance is adequate though not exhaustive.
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, the description carries the full burden. It discloses the authentication methods and the privacy concern about password retention, but does not describe side effects (e.g., whether the current user session is affected) or return behavior. The warning is valuable but incomplete.
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 efficient sentences that front-load purpose, then provide critical usage details. Every sentence adds value with no redundancy.
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?
Despite a large sibling list providing context, the description lacks details about the output schema (known to exist but unmentioned), does not describe all parameters, and omits behavioral aspects like session state changes. The overall coverage is inadequate for a complex 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 coverage is 0%. The description explains the 'method' and 'password' parameters implicitly, but does not mention 'total_timeout_seconds' or 'settle_timeout_seconds' at all. For 6 parameters, this is insufficient compensation.
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 ('Switch to a verified remote user') and the context ('within the existing JumpServer shell'). It distinguishes itself from sibling tools like jms_exit_terminal_user and jms_run_terminal_command by focusing on user switching.
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 explains when to use 'sudo' vs 'su' and when to supply a password. It also warns about password retention in trace history. However, it does not explicitly state when not to use this tool or mention alternatives beyond the methods.
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, the description carries the full burden of behavioral disclosure. It explicitly states that the tool not only closes the session but also expires its underlying connection token, a meaningful side effect beyond the name. However, it does not mention idempotency, permissions, or behavior on invalid handles, leaving some gaps.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Conciseness5/5
Is the description appropriately sized, front-loaded, and free of redundancy?
The description is a single sentence that states the core action and a key side effect, with no redundant information. It is front-loaded with the primary verb 'Close' and avoids any 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 tool is simple, and the output schema covers return values. However, the description lacks usage guidance and parameter semantics, and does not differentiate from the seemingly similar jms_interrupt_terminal_session. Given the absence of annotations, the description is minimally 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?
Schema description coverage is 0%, with only one parameter (session_handle). The description does not explain the format, provenance, or semantics of session_handle, and the schema only provides a title. Since the description must compensate for the lack of param documentation, this is a clear gap.
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+resource structure: 'Close a managed KoKo terminal session' and adds a differentiating detail about expiring the connection token. This clearly distinguishes it from sibling tools like jms_interrupt_terminal_session and jms_close_sftp_session.
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 by stating the tool closes a session and expires its token, but it does not provide explicit guidance on when to use this versus jms_interrupt_terminal_session or other session management tools. No alternatives or exclusions are mentioned, so the context is clear but underdeveloped.
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 full burden. It is a simple read-only operation with no side effects, but the description does not disclose potential details like authentication requirements or response format. It is not misleading, but it adds no behavior context beyond the verb 'Return'.
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 zero wasted words. It perfectly balances brevity and clarity for a simple tool.
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 no-parameter getter with an existing output schema, the description is complete: it states exactly what is returned (current JumpServer user profile) and nothing else is needed. The simplicity of the tool means the minimal description is sufficient.
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 schema coverage is 100% (empty schema). There is no parameter information needed, so the baseline of 4 applies. The description adds no parameter details, but none are required.
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 returns the current JumpServer user profile, using a specific verb and resource. It doesn't explicitly distinguish from sibling tools, but the purpose is unambiguous and the tool name reinforces the meaning.
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 offers no explicit guidance on when to use this tool versus the many sibling tools. The usage is implied (when the current user's profile is needed), but no alternatives, exclusions, or prerequisites are mentioned.
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, the description carries the burden. 'Return metadata' suggests a read-only operation, but it does not disclose error behavior, symlink handling, or permission requirements. The mention of 'absolute' adds some useful context.
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, front-loaded sentence with no filler. It efficiently communicates the tool's core purpose.
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 the tool's simplicity and the presence of an output schema, the description is mostly complete. It could be improved by mentioning the need for an active SFTP session, but overall it provides enough context for a straightforward stat operation.
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 meaning to the 'path' parameter by specifying it must be an 'absolute remote path'. However, 'session_handle' is only explained by its schema title, and with 0% schema coverage, the description only partially compensates.
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 'Return' and identifies the resource as 'metadata for one absolute remote path', clearly distinguishing it from sibling tools like jms_sftp_list which lists directory 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?
Usage is implied: use this tool to get metadata for a single remote path. However, it does not explicitly state when to prefer this over alternatives, nor does it provide exclusions or prerequisites.
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, the description carries the full burden. It clearly discloses the primary action (closing a session) and a side effect (cleaning up the connection token), making the destructive nature explicit. It could add idempotency or error behavior, but the core behavior is transparent.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Conciseness5/5
Is the description appropriately sized, front-loaded, and free of redundancy?
A single, front-loaded sentence effectively communicates the tool's purpose without unnecessary words. Every part of the description contributes 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?
Given the tool's simple nature and the presence of an output schema, the description adequately covers the main action. It could benefit from noting that session_handle comes from jms_acquire_sftp_session, but that is more of a parameter semantic concern; overall completeness is strong.
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 one parameter (session_handle) with no description and 0% schema coverage. The description does not mention the parameter at all, failing to explain that it is likely the handle returned from jms_acquire_sftp_session or how it should be formatted.
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 'Close' and clearly identifies the resource as a managed KoKo SFTP session, plus the additional cleanup of its connection token. This distinguishes it from sibling tools like jms_acquire_sftp_session or jms_list_sftp_sessions.
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 after acquiring an SFTP session, but does not explicitly state when to use it or mention alternatives like jms_close_terminal_session. It provides no when-to-use or when-not-to-use guidance.
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 responsibility for behavioral disclosure. It adds context by mentioning 'observed' methods and 'optionally narrowed' behavior, giving some insight into the data source and filtering capability. However, it does not explicitly state read-only status, permission requirements, or return format, leaving room for more 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 sentence that is front-loaded with the main action and resource, followed by the optional filtering behavior. Every word earns its place; there is no redundancy 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 simple list tool with an output schema, the description is largely complete. It covers the tool's purpose and the sole parameter. The main gap is that it does not elaborate on what 'connect methods' are or provide any background context, but given the tool's low complexity, this is adequate.
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 one optional parameter 'protocol' with no description (0% schema coverage). The description compensates by stating 'optionally narrowed to one protocol,' which clearly explains the parameter's purpose and usage. This provides meaningful semantics beyond the 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 clearly specifies the action ('List'), the resource ('JumpServer connect methods'), and adds a distinguishing qualifier ('observed'). This uniquely identifies the tool's purpose and differentiates it from sibling tools like jms_list_assets or jms_list_connection_tokens.
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: when one needs to list connect methods, optionally filtered by protocol. However, it does not explicitly state alternatives or when not to use it, nor does it reference sibling tools. Usage context is present but not comprehensive.
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, the description carries the full burden. 'List' implies a read-only operation, and 'observed' and 'exposed to current user' add some context about the data scope. However, it does not disclose authentication requirements, side effects, or any potential limitations beyond the name.
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 redundant wording. It immediately states the action and object.
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 parameterless list tool with an output schema, the description provides sufficient information: it names the resource and the user-specific scope. The word 'tree' implies a hierarchical structure, though it does not explicitly mention whether the result is a flat list or a nested tree, but the output schema covers return details.
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. Baseline 4 applies because the schema fully covers the (empty) parameter set.
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 'List' and names the resource 'observed JumpServer node tree' with scope 'exposed to the current user'. This clearly distinguishes it from sibling tools like jms_list_assets and jms_get_asset.
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 use for retrieving the node tree hierarchy but does not explicitly state when to use it over alternatives or mention any exclusions. No sibling tool is referenced for comparison.
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 are absent, so the description carries the full burden. The verb 'List' implies a read-only operation, and the scoping to 'current MCP process' adds context. However, it lacks explicit statements about no side effects, authentication, or return behavior, which would be more transparent.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Conciseness5/5
Is the description appropriately sized, front-loaded, and free of redundancy?
The description is a single, front-loaded sentence that directly states the tool's function without any filler. 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 that the tool takes zero parameters and has an output schema, the description sufficiently captures the tool's operation. No critical information is missing for a simple list operation.
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 zero parameters, the baseline is 4. The description adds no parameter semantics because there are no parameters to describe. The schema coverage is 100% by virtue of an 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 clearly states the action (list), the resource (active managed KoKo SFTP sessions), and the scope (current MCP process). This distinguishes it from the sibling jms_list_terminal_sessions, which lists terminal sessions.
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 used to view active SFTP sessions but provides no explicit guidance on when to use it versus alternatives. There are no exclusions or alternative tool references, though the name and context make the basic use case obvious.
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 full burden. It states the tool 'returns a recommended workflow,' which is transparent about its informational nature. However, it does not mention any potential side effects, authentication requirements, or limitations. Given the tool's simplicity, this is adequate but not rich.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
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 conveys the essential purpose immediately and earns its place without 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?
Given the tool's low complexity (zero parameters, no nested objects) and the presence of an output schema, the description suffices. It states the deliverable, though it could briefly mention that the workflow is specific to this MCP's terminal commands, which is already implied by the name.
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 score is 4. The description does not need to explain parameters, and the empty schema is self-explanatory.
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 'Return' and clearly identifies the resource: 'the recommended terminal workflow for coding agents using this MCP.' This unambiguously distinguishes it from sibling tools like jms_sftp_usage_guide and jms_paths, 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 establishes clear context by targeting 'coding agents using this MCP,' implying when it should be consulted. However, it does not explicitly state exclusions or alternative tools, so it stops short of full when/when-not guidance.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Behavior4/5
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
The description adds important scope information by noting 'in the current MCP server process', which is a behavioral constraint not otherwise disclosed. Since no annotations are provided, the description carries the burden, and the verb 'List' implies a read-only operation. This is sufficient for a simple list tool.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Conciseness5/5
Is the description appropriately sized, front-loaded, and free of redundancy?
The description is a single, front-loaded sentence with no unnecessary words. It immediately states the action and resource, making it highly concise and well-structured.
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 list tool with an output schema, the description is complete. It specifies purpose and scope, and the output schema handles return value documentation. No additional behavioral context is needed for this simple operation.
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 100% (empty object). The baseline for 0 parameters is 4, and the description adds no parameter-specific information, which is appropriate given there are none.
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 ('List') and clearly defines the resource ('active managed KoKo terminal sessions') with a scope qualifier ('in the current MCP server process'). It effectively distinguishes from sibling tools like jms_list_sftp_sessions by specifying terminal sessions and the managed KoKo context.
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 indicates the tool's context (active sessions in the current process) without explicit exclusions or alternatives. While it doesn't name alternative tools, the 'list' verb and scope make it obvious when to use it, qualifying as clear context with no exclusions.
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?
With no annotations provided, the description carries the full burden of disclosing behavior. It transparently states that the tool returns workflow guidance and safety rules, which is exactly what it does. There is no indication of side effects or hidden behavior, and the 'Return' verb makes the read-only nature clear.
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 one sentence, front-loaded with the action, and contains no unnecessary words. It efficiently conveys both key aspects of the guide (workflow and safety rules) in a compact format.
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 simple usage-guide tool with no parameters and an output schema, the description is complete. It informs the agent about the two critical content areas—recommended workflow and safety rules—which is all that is needed to decide when to invoke the 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 description does not need to add parameter semantics, and it correctly omits any parameter-related details that would be irrelevant.
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 purpose with a specific verb 'Return' and identifies the resource: the recommended SFTP workflow and destructive-operation safety rules. It distinguishes itself from sibling tools like jms_terminal_usage_guide by explicitly mentioning SFTP, making the 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 Guidelines4/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 by mentioning 'destructive-operation safety rules,' suggesting it should be consulted before performing destructive SFTP operations. However, it does not explicitly name alternatives or state when not to use it, so it stops short of full explicit guidance.
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:

[![mcp-jumpserver-gui-sucks MCP server](https://glama.ai/mcp/servers/ArtiPyHeart/mcp-jumpserver-gui-sucks/badges/card.svg)](https://glama.ai/mcp/servers/ArtiPyHeart/mcp-jumpserver-gui-sucks)

Score Badge

Copy to your README.md:

[![mcp-jumpserver-gui-sucks MCP server](https://glama.ai/mcp/servers/ArtiPyHeart/mcp-jumpserver-gui-sucks/badges/score.svg)](https://glama.ai/mcp/servers/ArtiPyHeart/mcp-jumpserver-gui-sucks)

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/ArtiPyHeart/mcp-jumpserver-gui-sucks'

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