jan-terminal-mcp

Overview Schema Related Servers Score Discussions

Server Quality Checklist

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

Latest release: v0.1.0
Disambiguation2/5
The run_* family is heavily overlapping: run_code, run_python, and run_cpp all execute code, with run_python and run_cpp being subsets of run_code. run_file and run_shell also blur boundaries, making it easy to select the wrong tool.
Naming Consistency4/5
Most tools follow a clear verb_noun pattern (read_file, write_file, list_dir, edit_file, run_code, etc.). The single exception is 'git' (a plain command name) and to a lesser extent 'run_shell' which still matches the pattern, so only a minor deviation.
Tool Count4/5
10 tools is within the ideal range, but the redundancy of run_python and run_cpp with run_code makes the set feel slightly over-scoped. Still, the count is reasonable for a terminal/file server.
Completeness4/5
The tool surface covers git, shell, file read/write/edit/list, and code execution, which is solid for a terminal. Minor gaps include no delete_file or rename operation, but these can be worked around with run_shell.
Average 3.4/5 across 10 of 10 tools scored. Lowest: 2.3/5.
See the Tool Scores section below for per-tool breakdowns.
- No community issues in the last 6 months
- 16 commits in the last 12 weeks
- No stable releases found
- No critical vulnerability alerts
- No high-severity vulnerability alerts
- No code scanning findings
- CI status not available
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

Behavior1/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 'run a PowerShell command' but fails to mention side effects, security implications, permission requirements, output/error handling, or whether the command executes synchronously. For a shell execution tool, this is a critical transparency gap.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Conciseness2/5
Is the description appropriately sized, front-loaded, and free of redundancy?
The description is a single sentence, which is concise in length but under-specified for the complexity of the tool. It lacks necessary details and is closer to an under-specification than a model of conciseness. The sentence is front-loaded, but the brevity detracts from its utility.
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?
For a shell execution tool with no annotations, two parameters, and no description of return values or side effects, this description is completely inadequate. Even with an output schema, the description fails to provide essential context about when to use it, what to expect, or how parameters affect execution.
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 does not compensate. It does not mention the 'command' parameter or the 'cwd' parameter, nor does it explain defaults, formatting, or how the command is interpreted. The agent is left with no semantic understanding beyond 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 states a specific action ('Run') and a specific resource ('a PowerShell command on the user's machine'), which clearly differentiates it from siblings like run_python (Python) and run_cpp (C++). The explicit mention of 'PowerShell' distinguishes it from generic run_code or run_file, giving it a clear 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?
No guidance is provided on when to use this tool versus alternatives. It does not mention prerequisites, exclusions, or complementary tools. The description 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?
No annotations are provided, so the description carries the full burden. It only states the basic action without disclosing behavior such as output format, error handling, permission requirements, or content encoding.
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 words or filler, making it easy to parse.
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 description is minimally viable but lacks usage context, parameter details, and explicit behavioral notes. Even though an output schema exists, the description does not fully equip the agent to select and invoke the tool correctly in varied scenarios.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Parameters1/5
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
The description does not mention the 'path' parameter or provide any additional context. With schema description coverage at 0%, the agent receives no help beyond the parameter name itself.
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 identifies the resource as 'a file on the user's machine', clearly distinguishing it from sibling tools like write_file or list_dir.
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. It does not mention contexts, exclusions, or alternative tools, leaving the agent to infer usage solely from the name.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Behavior2/5
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
No annotations are provided, so the description carries the full burden of disclosing behavior. It mentions executing code and returning output, but omits critical details like sandboxing, process isolation, timeouts, side effects, error handling, and whether filesystem/network access is permitted. For a code execution tool, this is a significant transparency 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 a single sentence, clear, and front-loaded with the action. Every word contributes to the meaning, and there is 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?
Although an output schema exists, this is a code execution tool that carries significant complexity and risk. The description omits essential context about the execution environment, installed packages, resource limits, security implications, and interaction with the filesystem. An agent would not have enough information to invoke this tool safely and effectively.
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 adds almost no parameter-level meaning. The verb 'Execute Python code' implies the 'code' parameter holds the Python source, but the 'cwd' parameter's purpose is completely unexplained. Since the description does not explicitly reference parameters, it fails to compensate for the schema's lack of descriptions.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Purpose5/5
Does the description clearly state what the tool does and how it differs from similar tools?
The description 'Execute Python code directly and return the output' is specific, naming the exact resource (Python code) and the action (execute), and distinguishes this tool from siblings like run_shell, run_file, and run_cpp by clarifying it runs Python code inline. It goes beyond a simple restatement of the tool's name.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Usage Guidelines2/5
Does the description explain when to use this tool, when not to, or what alternatives exist?
The description provides no guidance on when to use this tool versus alternatives such as run_file (for Python files) or run_code (for generic code execution). It only states what the tool does, leaving the agent to infer usage from the tool name and sibling context.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Behavior3/5
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
The description explicitly mentions 'overwrite', disclosing that existing files can be replaced, which is a key destructive behavior. With no annotations provided, this is important, but the description lacks additional behavioral context such as path handling, directory creation, or error behavior.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Conciseness5/5
Is the description appropriately sized, front-loaded, and free of redundancy?
The description is two sentences long and front-loads the primary purpose. The second sentence adds a relevant workflow warning without unnecessary verbosity.
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 function and an important execution workflow rule. Since an output schema exists, return values are likely documented there. However, the description omits guidance on when to prefer write_file over edit_file for existing-file modifications, leaving some contextual gaps.
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 defines only path and content with no descriptions, and the description provides no additional parameter semantics. The parameter names are self-explanatory, but the description fails to compensate for the zero schema coverage.
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 function with the verb 'write/overwrite' and identifies the resource as 'a file on the user's machine.' It distinguishes itself from run_code by warning against using run_code for the same code, but it does not explicitly contrast with edit_file, a sibling tool for file modification.
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 provides a specific workflow tip: after writing code, use run_file to execute it and avoid run_code. However, it does not offer broader guidance on when to choose write_file over edit_file or other file-related tools, leaving usage context partially unspecified.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Behavior2/5
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
No annotations are provided, so the description carries the full burden of disclosing behavior. It only states basic functionality without mentioning whether listing is recursive, includes hidden files, sorts results, or rejects non-directory paths, leaving important behavioral aspects 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, direct sentence that clearly states the tool's function without redundant words. It is appropriately sized for a simple utility and is easy to parse.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Completeness3/5
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
For a single-parameter listing tool, the description conveys the core purpose and an output schema exists to document return values. However, it lacks behavioral details like recursion and hidden-file handling, and provides no guidance on typical use cases, making it adequate but not fully complete.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Parameters2/5
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
The input schema defines only 'path' with no description (schema coverage 0%). The tool description does not elaborate on the parameter's expected format (absolute/relative), type constraints, or default behavior. The word 'directory' in the description loosely implies 'path' is a directory, but no concrete semantics are added.
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 'List files and folders in a directory' clearly identifies the action (listing) and resource (directory contents), and it is distinct from sibling tools like read_file (file contents) or run_shell (commands).
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Usage Guidelines3/5
Does the description explain when to use this tool, when not to, or what alternatives exist?
The usage context is implied by the tool's name and description: it is for enumerating directory entries. However, there is no explicit mention of when to prefer this over alternatives like run_shell (with ls) or read_file, nor 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?
No annotations are provided, so the description carries full responsibility for disclosing behavior. It only says 'Run a git command' and gives examples, but does not mention potential side effects (e.g., mutations from commit/push), error handling, or return value format. This is a significant gap for a tool that can execute arbitrary git commands.
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 plus examples, immediately stating the tool's action. It is front-loaded and concise, with no wasted words, achieving maximum clarity in minimal space.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Completeness3/5
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
Given the tool's simplicity, the description covers the basic command invocation, but it omits important context such as return behavior and cwd semantics. Since an output schema exists, return values may be partially covered, but the lack of usage guidance and cwd explanation keeps this at a minimum viable level.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Parameters3/5
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
Schema description coverage is 0%, so the description must compensate. It clarifies the 'args' parameter with concrete examples, but the 'cwd' parameter is not explained at all. The examples add meaningful context, but the incomplete coverage of cwd prevents a higher score.
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 runs a git command with specific examples. It distinguishes itself from siblings like run_shell by focusing exclusively on git operations, 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 Guidelines3/5
Does the description explain when to use this tool, when not to, or what alternatives exist?
The description gives a clear sense of usage via examples ('status', 'log --oneline -10', 'commit -m "fix bug"'), but it does not explicitly state when to use this tool vs alternatives like run_shell, nor does it mention 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 provided, the description carries the full burden. It discloses that language is auto-detected, but does not mention error handling, side effects, execution environment, or output behavior, leaving significant gaps for an agent.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Conciseness5/5
Is the description appropriately sized, front-loaded, and free of redundancy?
The description is two concise sentences, front-loaded with the primary purpose and a practical tip. Every word earns its place, with no redundancy.
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 output schema exists, return values need not be explained. The tool is simple, but the description could mention prerequisites like file existence or how execution is handled. It is adequate but not exhaustive.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Parameters3/5
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
Schema description coverage is 0%, so the description must compensate. It clarifies that language is optional and auto-detected, giving meaning to that parameter. Path is implied as the existing file path but not elaborated further.
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 runs an existing file and distinguishes it from write_file. It could more explicitly differentiate from run_shell or run_code, but the verb+resource combination 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 Guidelines4/5
Does the description explain when to use this tool, when not to, or what alternatives exist?
The description explicitly recommends using this tool after write_file to avoid rewriting code, providing a clear context of use. It does not exclude other run tools or mention when not to use it, but it offers actionable 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?
With no annotations, the description discloses that execution happens without saving to disk and is intended for quick one-off runs, which implies ephemerality. However, it does not mention potential side effects, sandboxing, network access, or execution limits, which is a notable gap for a code execution 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?
Three sentences, each with a distinct purpose: core action, usage guidance, and supported languages. No redundancy or filler, and the most critical information is front-loaded.
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 tool's core purpose, usage context, and language support, and the presence of an output schema may cover return values. However, it omits explanation of the cwd parameter and does not address safety or environmental behavior, making it only moderately complete for a code execution tool with no annotations.
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 zero description coverage, and the description only partially compensates. It lists supported languages (useful for the language parameter) and implicitly defines code as a snippet, but does not mention or explain the cwd parameter at all.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Purpose5/5
Does the description clearly state what the tool does and how it differs from similar tools?
The description opens with a specific verb+resource combination ('Execute a code snippet directly') and immediately clarifies the no-disk-save behavior. It distinguishes from run_file by naming it as the alternative for already-written code, and the supported language list defines scope.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Usage Guidelines4/5
Does the description explain when to use this tool, when not to, or what alternatives exist?
The description explicitly states when to use this tool ('quick one-off runs') and provides a clear when-not scenario with an alternative tool ('If you already wrote the code with write_file, use run_file instead'). However, it does not differentiate from run_shell or language-specific wrappers like run_python/run_cpp, leaving some sibling boundaries implicit.
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 carries full responsibility for behavioral disclosure. It states the replacement action but fails to mention key behaviors: whether replacement is global or first-occurrence, error handling if old_text is not found, whether the file must already exist, or side effects on file attributes. This is a significant transparency gap for a mutation tool.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Conciseness5/5
Is the description appropriately sized, front-loaded, and free of redundancy?
The description is two concise, front-loaded sentences with no unnecessary information. It efficiently conveys the core action and primary use case.
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 with an output schema, the description covers the basic operation and use case. However, it omits edge-case handling such as missing old_text or non-existent files, which is important for an agent to predict outcomes. With no annotations, a bit more detail would make it complete.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Parameters3/5
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
Schema descriptions are completely absent (0% coverage), so the description must compensate. It explains old_text as the text to find and new_text as the replacement, but does not clarify path expectations (e.g., must exist, absolute/relative) or constraints on old_text uniqueness. This adds some meaning but leaves parameters under-specified.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Purpose5/5
Does the description clearly state what the tool does and how it differs from similar tools?
The description clearly states the tool edits a file by replacing old_text with new_text, using a specific action verb and resource. It also differentiates from sibling write_file by noting 'instead of rewriting the whole file.'
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Usage Guidelines5/5
Does the description explain when to use this tool, when not to, or what alternatives exist?
Explicit usage guidance is provided: 'Use this to fix errors instead of rewriting the whole file,' which clearly tells the agent when to choose edit_file over rewriting the entire file (write_file).
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 transparently states that it returns compiler errors or program output, which are key behavioral outcomes. However, it does not disclose other potentially important behaviors such as side effects of program execution, timeouts, or how the working directory (cwd) affects execution. It is adequate but not richly detailed.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Conciseness5/5
Is the description appropriately sized, front-loaded, and free of redundancy?
The description is two short sentences, immediately stating the main purpose and return value. Every word earns its place, with no extraneous information, 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.
Completeness4/5
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
For a simple compile-and-run tool with only two parameters (one required) and an output schema, the description is largely complete: it covers the tool's purpose, the type of code, and the return. However, it omits any explanation of the 'cwd' parameter, which could affect program behavior. The overall context is sufficient for typical 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?
The schema provides no descriptions for the 'code' and 'cwd' parameters, and schema coverage is 0%. The description only mentions 'C++ code', which vaguely relates to the 'code' parameter but offers no explanation for 'cwd'. It fails to compensate for the low schema coverage.
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 ('Compile and run C++ code') and identifies the resource (C++ code), immediately distinguishing it from sibling tools like run_python or run_shell. It also explains what the tool returns (compiler errors or program output), which further clarifies its function.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Usage Guidelines4/5
Does the description explain when to use this tool, when not to, or what alternatives exist?
The description provides clear context: it is for C++ code specifically. This implies when to use it (whenever C++ code needs to be compiled and run) without explicitly naming alternatives or exclusions. Since siblings exist for other languages and generic execution, the context is clear, but no direct comparison or exclusion is given.
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:

[![jan-terminal-mcp MCP server](https://glama.ai/mcp/servers/Trigodil/jan-terminal-mcp/badges/card.svg)](https://glama.ai/mcp/servers/Trigodil/jan-terminal-mcp)

Score Badge

Copy to your README.md:

[![jan-terminal-mcp MCP server](https://glama.ai/mcp/servers/Trigodil/jan-terminal-mcp/badges/score.svg)](https://glama.ai/mcp/servers/Trigodil/jan-terminal-mcp)

Latest Blog Posts

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

MCP directory API

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

curl -X GET 'https://glama.ai/api/mcp/v1/servers/Trigodil/jan-terminal-mcp'

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