MS-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.2.0
Disambiguation4/5
Most tools have distinct purposes, but some overlap exists, e.g., ms_gui_create_crystal_current vs. ms_gui_create_current, and multiple CASTEP-related tools could confuse. Descriptions are detailed enough to resolve ambiguity in most cases.
Naming Consistency3/5
The naming follows a general ms_<area>_<action>_<object> pattern, but inconsistencies exist: ms_list_workspace lacks an area prefix, ms_status and ms_codex_config deviate. The frequent use of 'current' suffix is not universal.
Tool Count3/5
24 tools is on the higher side for an MCP server, but the domain (Materials Studio) is complex. However, many tools are specialized (e.g., 5 CASTEP tools), making the set feel slightly bloated.
Completeness3/5
The tool set covers core workflows (GUI manipulation, calculations, status checks) but has notable gaps: no delete/removal tools, no general job management, and limited non-CASTEP module support. Some operations require multiple tools where a single one might suffice.
Average 3.2/5 across 23 of 24 tools scored. Lowest: 2.4/5.
See the Tool Scores section below for per-tool breakdowns.
- No community issues in the last 6 months
- 23 commits in the last 12 weeks
- Last stable release on July 18, 2026
- 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

Behavior2/5
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
No annotations are present, so the description carries full responsibility for behavioral disclosure. It only states that the tool runs a task, without mentioning side effects, whether it is synchronous, error handling, or required permissions. This is insufficient for an agent to anticipate the tool's behavior.
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 sentence and is concise, but it lacks critical information. While it has no filler, the brevity comes at the expense of completeness, failing to earn its place with substantive guidance.
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 the tool's complexity (5 parameters, no output schema, no parameter descriptions, no annotations), the description is severely incomplete. It does not explain return values, how to structure input, or any constraints. An agent would have insufficient information to use the tool correctly.
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%, meaning no parameter descriptions in the schema. The description does not add any meaning to parameters like 'inputDocument', 'task', 'cores', 'project', or 'settings'. For instance, 'inputDocument' is required but no format or location details are given. The tool's parameters remain completely undocumented.
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 that the tool runs a Forcite task on an input document under the MS-MCP work root, using a specific verb and resource. However, it does not differentiate this tool from siblings like ms_castep or ms_run_materialscript, which also run computational tasks.
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 (e.g., ms_castep). The description lacks context about prerequisites, typical 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?
No annotations are provided, so the description carries full burden. It mentions 'Queue' implying asynchronous operation and 'manual-like calculation folder layout' but does not disclose side effects, required state, permission needs, or output behavior. Significant gaps remain.
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 sentence, so it is concise, but it lacks structure. It is appropriately sized for a simple tool but could be more informative without becoming verbose.
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 11 parameters with zero schema descriptions, no annotations, and no output schema, the description is severely incomplete. It fails to explain parameter meanings, return values, prerequisites, or error conditions, leaving agents with insufficient information.
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 coverage is 0%, yet the description adds no explanation for any of the 11 parameters. It does not list or describe cores, quality, forcefield, etc. The description adds no value beyond the parameter names and defaults in the schema.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Purpose4/5
Does the description clearly state what the tool does and how it differs from similar tools?
The description clearly states it queues a Forcite GeometryOptimization on the current GUI document, using a specific folder layout. It distinguishes from siblings like ms_gui_dmol3_optimize_current (different engine) and ms_gui_castep_current (different method), but does not explicitly differentiate from other Forcite-related tools.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Usage Guidelines2/5
Does the description explain when to use this tool, when not to, or what alternatives exist?
There is no guidance on when to use this tool versus alternatives. The description implies usage for Forcite optimization on the current document but lacks context on prerequisites, when not to use, or alternative tools for other tasks.
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 provided. The description says 'in place' implying mutation, but does not disclose side effects, required document state, or any destructive behavior. Minimal transparency.
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 sentence, concise but under-specified. It earns a middle score due to brevity, but lacks necessary details.
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?
With 9 parameters, no output schema, and no annotations, the description is severely incomplete. It fails to explain parameter usage, units, or behavior, making it inadequate for correct agent 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 does not mention any parameters. The 9 parameters (a, b, c, alpha, beta, gamma, exportFile, ballAndStick, documentName) are completely undocumented in the description, providing no semantic guidance beyond the schema.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Purpose4/5
Does the description clearly state what the tool does and how it differs from similar tools?
The description clearly states the action (set) and resource (lattice parameters on current GUI crystal document, in place). It is specific enough to distinguish from other GUI tools like create or make supercell, though not explicitly differentiated from siblings.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Usage Guidelines2/5
Does the description explain when to use this tool, when not to, or what alternatives exist?
No guidance provided on when to use this tool vs alternatives (e.g., creating a new crystal or modifying via other tools). No prerequisites or conditions mentioned.
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 disclose behavioral traits. It only states 'list files' without indicating if the operation is read-only, has side effects, or requires authentication. The lack of transparency is significant for a tool with no annotations.
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, which is concise, but it sacrifices necessary detail. It is under-specified for an effective tool description, though no redundant information is present.
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 complexity (2 parameters, no output schema, no annotations), the description is incomplete. It does not explain parameter usage, return format, or filtering behavior, leaving the agent without crucial information for correct 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%, meaning parameters have no descriptions. The tool description does not mention parameters at all, providing no additional meaning for 'subdir' or 'maxFiles'. The agent cannot infer their semantics from the description.
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 lists files under the MS-MCP work root, providing a specific verb and resource. It is not a tautology and distinguishes from siblings like ms_status or ms_gui_project_dir. However, it lacks detail on whether directories are included or recursion behavior.
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 on when to use this tool versus alternatives. The description does not mention context, prerequisites, or exclusions, leaving the agent to infer usage from the name alone.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Behavior2/5
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
No annotations are present, and the description fails to disclose behavioral traits such as blocking behavior, state changes, permissions required, or side effects of queuing. While it mentions 'queue a calculation,' it does not describe what happens after queuing, nor does it discuss error conditions or success indicators.
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 brief with two sentences, no redundancy. However, the list of presets could be trimmed if the schema enum for calculationType is sufficiently descriptive. The structure is acceptable but could be improved with bullet points or clearer separation of presets from the main action.
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 complexity (9 parameters, no annotations, no output schema), the description lacks essential context. It does not explain the meaning of 'current GUI document,' the output format, error handling, or any dependencies. The agent is left without enough information to use the tool confidently.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Parameters2/5
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
With only 11% schema description coverage, the description adds minimal value beyond listing the calculation presets that correspond to the calculationType parameter. It does not explain critical parameters like cores, quality, exportFile, or extraSettings, leaving the agent underinformed about their purpose and constraints.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Purpose4/5
Does the description clearly state what the tool does and how it differs from similar tools?
The description clearly states the tool queues a CASTEP calculation on the current GUI document and lists supported presets. It specifies the action ('Queue') and resource ('CASTEP calculation'). However, it does not explicitly differentiate from sibling tools like ms_gui_prepare_remote_castep_batch or ms_castep, leaving room for ambiguity about local vs. remote execution.
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 such as ms_gui_prepare_remote_castep_batch for remote submissions or ms_castep for general CASTEP tasks. The description lacks any usage context or prerequisites, making it harder for an agent to decide 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?
No annotations are provided, so the description bears full responsibility for behavioral disclosure. The description mentions 'queues' (implying asynchronous operation) and 'modifies in place', but does not elaborate on destructive potential, authentication requirements, rate limits, or what happens to the document state. This is insufficient for a tool that modifies the GUI.
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 consists of two sentences and is front-loaded with the core purpose. It is concise with no redundant information. However, the brevity sacrifices completeness for a tool with six parameters.
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 complexity (6 parameters, no output schema, no annotations), the description is far from complete. It does not explain return values, side effects, or parameter usage. The agent cannot fully understand how to invoke the tool correctly without additional context.
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 only 17%, meaning the description adds no value for most parameters. The tool description does not explain any parameter beyond what the schema already provides for 'body'. With 6 parameters (1 required) and no parameter descriptions in the description itself, the agent lacks essential semantic guidance.
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 verb 'queue' and the resource 'MaterialsScript body that modifies the current GUI document'. It provides an example use case ('on this molecule...' edits), making the purpose clear. However, it does not explicitly differentiate from sibling tools like ms_gui_create_current or ms_gui_edit_current.
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 includes guidance to 'Use this for 'on this molecule...' edits', implying a context for use. However, it does not specify when not to use this tool, nor does it mention alternatives among the many sibling GUI tools. The usage context is implied but not exhaustive.
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?
Without annotations, the description carries full burden. It mentions queuing and output organization but does not disclose side effects, blocking behavior, error conditions, or any limitations. The agent lacks insight into what happens during execution.
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?
Single sentence, efficient and front-loaded with the core action. However, it could be slightly expanded without becoming verbose to cover parameter or usage hints.
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 9 parameters, no annotations, and sibling optimization tools, the description is incomplete. It does not address parameter roles, output behavior, or how the calculation name/folder is used. Lacks critical context for correct usage.
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 explain any of the 9 parameters. No parameter is described beyond their schema types. The description adds no semantic value for parameter usage.
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 it queues a DMol3 GeometryOptimization on the current GUI document and organizes outputs. The verb 'queue' and resource 'DMol3 GeometryOptimization' are specific, and it distinguishes from sibling tools like Forcite or CASTEP optimizations.
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 on when to use this tool versus alternatives (e.g., Forcite, CASTEP). No prerequisites (e.g., an open document) or conditions for use are mentioned.
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 provided, so description carries full burden. It mentions 'in place' implying modification but doesn't disclose whether the original is preserved, whether it's destructive, or any permissions needed. It references 'Materials Studio BuildSuperCell' but doesn't clarify side effects. Parameter calculateBonds has a good warning, but overall behavioral context is lacking.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Conciseness5/5
Is the description appropriately sized, front-loaded, and free of redundancy?
Single sentence that directly states the purpose without unnecessary words. Efficient and 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?
With 8 parameters, no output schema, and no annotations, the one-sentence description is insufficient. It omits context about return values, error conditions, overwriting behavior, or confirmation steps. More detail is needed for a tool that modifies the current document.
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 63% (5 of 8 parameters described). The tool description does not add any meaning beyond the schema; it only names the underlying method. For a moderate coverage, the description should have compensated but didn't.
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 ('Build a supercell') and the resource ('current GUI periodic document'), with specific verb and resource. It distinguishes from siblings like ms_gui_create_current or ms_gui_set_lattice_current by focusing on supercell construction. Minor vagueness in 'in place' prevents a 5.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Usage Guidelines2/5
Does the description explain when to use this tool, when not to, or what alternatives exist?
No guidance on when to use this tool versus alternatives (e.g., ms_gui_create_current for new structures, ms_gui_set_lattice_current for lattice changes). No exclusions or prerequisites 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. It explains the default native_castep mode and the staging process, but omits details about the submissionMode other modes, the effect of stopGuiLoopAfterPrepare, and potential side effects or prerequisites.
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 two sentences and front-loaded with the core purpose. The second sentence adds relevant detail about the default mode but could be slightly tighter; still efficient overall.
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 complexity (5 params, nested objects, no output schema), the description fails to cover parameters and return behavior. Important context like what happens after preparation or the output format is missing, making it incomplete for reliable 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%; the description does not explain any of the five parameters (tasks, batchName, commonSettings, submissionMode, stopGuiLoopAfterPrepare), leaving the agent without semantic guidance 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 states the tool prepares native CASTEP geometry-optimization jobs or script drivers, specifying two modes and how the default mode stages documents per task. It distinguishes itself from sibling tools like ms_castep and ms_gui_castep_current by focusing on batch preparation.
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 on when to use this tool versus alternatives (e.g., ms_castep, ms_remote_castep_record_submission). The description mentions two modes but does not explain when to choose one over the other or provide 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 provided. Description does not disclose whether the operation is read-only, requires authentication, or what happens if queues are empty or folders missing.
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?
Single concise sentence with no redundancy. Could be more structured, but adequately conveys purpose with minimal 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?
No output schema and no description of return values. Lacks information on what the user can expect after invoking the tool (e.g., list of queue folders or status messages).
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Parameters4/5
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
Tool has no parameters, so schema coverage is complete. Description adds context by naming the specific resource being inspected, which is meaningful beyond the empty schema.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Purpose4/5
Does the description clearly state what the tool does and how it differs from similar tools?
The description specifies a clear verb 'Inspect' and resource 'optional MS-MCP GUI queue folders', distinguishing it from siblings like 'ms_status'.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Usage Guidelines2/5
Does the description explain when to use this tool, when not to, or what alternatives exist?
No guidance on when to use this tool versus alternatives such as 'ms_status' or 'ms_remote_castep_batch_status'.
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 present, so the description carries the full burden. It mentions 'queue' but does not disclose asynchronous behavior, how to check completion, undo capabilities, or any side effects. The list of operations provides some insight but misses behavioral details.
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 concise and front-loads the purpose. However, it could be slightly more structured by breaking into bullet points or sentences for clarity. No redundant information.
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 complexity (17 parameters, no output schema, no annotations), the description is insufficient. It does not explain return values, the queueing mechanism, prerequisites, or the broader context of molecular modeling. The description leaves significant 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?
Schema description coverage is only 24% (4 out of 17 parameters have descriptions). The tool description adds context for the 'operation' parameter by listing examples but does not explain critical parameters like x, y, z, name, exportFile, or documentName. The parameter meanings remain unclear.
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 verb 'Queue' and the resource 'current GUI document', and lists specific operations like adding/deleting bonds, changing element, etc. This distinguishes it from sibling tools like crystal creation or lattice settings.
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 basic molecule-building edits on the current document but does not explicitly state when to use this tool versus alternatives like ms_gui_create_crystal_current or ms_gui_set_lattice_current. No 'when-not-to-use' guidance 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?
The term 'Ensure' is ambiguous—it may imply creating the directory if it doesn't exist, which is a behavioral trait. Without annotations, the description does not clarify whether side effects (e.g., creation) occur, nor does it mention permissions, idempotency, or error conditions. This lack of transparency could lead to misuse.
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 of 14 words, front-loading the key action ('ensure and return'). It is efficient, though the word 'ensure' could be clarified for better scannability.
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 absence of annotations and output schema, the description carries the full burden of explaining the tool's behavior. It omits details about the return value format, whether the directory is created, and any required permissions. For a simple tool, this may be marginally adequate, but it lacks completeness for an AI agent to understand all nuances.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Parameters4/5
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
The input schema has zero parameters, so schema description coverage is 100%. According to guidelines, a baseline of 4 is appropriate. The description does not need to add parameter information, and it provides no misleading 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 clearly identifies the tool's purpose: to ensure and return the current MS-MCP session output directory. The verb 'ensure and return' combined with the resource 'directory' provides specific action and object, distinguishing it from sibling tools like ms_gui_state or ms_list_workspace which have different scopes.
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 when the current session output directory is needed, but does not explicitly state when to use this tool versus alternatives like ms_list_workspace. No exclusions or prerequisites are provided, leaving the agent to infer 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 must disclose behavioral traits. It states what is read but fails to mention safety, authentication needs, side effects, or error behavior, leaving 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 sentence with no extraneous words, making it efficient. However, it could be more specific without adding length.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Completeness2/5
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
For a tool with one parameter and no output schema, the description omits critical context such as return format, error conditions, prerequisites (e.g., batch must be submitted), and any side effects.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Parameters2/5
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
With 0% schema description coverage, the description should add meaning for the single parameter 'batchName'. It only references 'remote CASTEP batch' without clarifying the parameter's format, semantics, or how it relates to the batch.
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 ('Read') and the specific resources ('local preparation markers, submission receipt, and downloaded result summary') for a remote CASTEP batch, effectively distinguishing it from sibling tools like ms_remote_castep_record_submission.
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 a remote CASTEP batch is prepared and submitted, but lacks explicit guidance on when to use versus alternatives or any prerequisites 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?
No annotations are provided, so the description bears full responsibility. It mentions the disabling mechanism but does not disclose side effects, authentication needs, error handling, or resource consumption. For a tool that runs arbitrary scripts, this is insufficiently 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 sentence plus a two-part condition. Every word serves a purpose with no redundancy, starting directly with the action verb 'Run'.
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 the tool's complexity (5 parameters, no output schema, no annotations) and its potential danger (arbitrary script execution), the description is severely incomplete. It lacks details on script format, return values, error behavior, and prerequisite setup beyond the env var.
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 parameter schema has 0% description coverage, and the description adds no semantic meaning to any of the five parameters. The script, args, name, cores, and project parameters are not explained beyond their types and defaults in 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 states 'Run a MaterialsScript Perl script', specifying the verb and resource. It also mentions the disabling mechanism, distinguishing it from sibling tools like ms_castep or ms_forcite that handle specific computations.
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 notes it is disabled by default unless the environment variable MS_MCP_ALLOW_ARBITRARY_SCRIPT is set to 1. This provides clear when-to-use and when-not-to-use guidance, though it lacks references to alternative tools for non-arbitrary script execution.
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 disclose behavioral traits. It only says 'Run' with no details on execution mode, side effects, or requirements. Agents lack information on whether it blocks, modifies files, or requires licenses.
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?
Description is a single sentence followed by a preset list. It is front-loaded and efficient, though the preset list could be integrated more seamlessly. No redundant phrases.
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 complexity (5 params, nested objects, no output schema), the description omits return values, error handling, and detailed parameter usage. It is insufficient for agents to predict tool behavior fully.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Parameters3/5
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
Schema coverage is low (20%). Description adds meaning for 'inputDocument' (location under work root) and 'task' (lists presets), but fails to explain 'cores', 'project', and 'settings'. Agents need more parameter documentation.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Purpose5/5
Does the description clearly state what the tool does and how it differs from similar tools?
The description clearly states it runs a CASTEP task or preset calculation on an input document. It lists specific presets, making the purpose concrete and distinguishable from sibling tools like ms_forcite.
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 CASTEP tasks under the MS-MCP work root but lacks explicit when-to-use or when-not-to-use guidance. It does not mention prerequisites or alternatives, so agents may misuse it.
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 burden. It mentions using SurfaceBuilder + CrystalBuilder but fails to disclose whether the operation modifies the current crystal, creates a new document, or requires specific permissions. The agent is left unaware of side effects.
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 with no redundant information. The key action is front-loaded, and the usage condition is stated directly. Every sentence adds value.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Completeness2/5
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
With 14 parameters, no output schema, and no explanation of common parameters, the description is insufficient. It does not cover what the tool returns or how parameters like h,k,l affect the result. The tool's complexity demands more context.
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 only 14% (2 out of 14 parameters have descriptions). The description adds no parameter information, failing to compensate for the low coverage. Most parameters like h,k,l, capType, cleaveRule, etc., remain unexplained.
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 action: 'Cleave a surface from the current GUI crystal and build a vacuum slab' using specific builders. It also distinguishes usage from siblings by specifying when to use it, referencing the manual surface workflow.
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 explicit guidance: 'Use only when the user explicitly asks...' This sets a clear condition. However, it does not mention alternatives or when not to use, limiting differentiation from sibling tools like ms_gui_add_vacuum_current.
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 explains that the tool modifies the document in place and describes the behavior of the two modes. With no annotations provided, it adds some transparency but does not cover side effects, permissions, or prerequisites.
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 with no redundant information. It front-loads the core purpose and follows with mode explanations, making it efficient and well-structured.
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 9 parameters and no output schema, the description is insufficient. It covers the main action and two modes but omits parameter details, return behavior, and prerequisites, leaving the agent underinformed.
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 only 11% (only thickness has a description). The description adds context for 'mode' and implies 'axis' by mentioning 'chosen lattice length', but does not explain other parameters like exportFile, ballAndStick, documentName, etc.
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 adds vacuum to the current GUI periodic document 'in place' and only when explicitly requested. However, it does not differentiate from the sibling 'ms_gui_cleave_surface_vacuum_current', which also deals with vacuum.
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 the tool is used when the user asks for vacuum and explains when to use each mode (extend_lattice for 3D cells, vacuum_slab for 2D surfaces). However, it lacks guidance on when not to use this tool versus alternatives.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Behavior3/5
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
No annotations are provided, so the description carries the full burden. It says 'Record one Materials Studio Job Control receipt', implying a write operation, but does not disclose whether the operation is idempotent, what happens on duplicates, or any side effects. It gives basic context but lacks depth on 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, front-loading the purpose and then the usage guideline. Every sentence is concise and to the point, with no verbose or redundant content.
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 10 parameters, no output schema, and no annotations, the description is incomplete. It covers purpose and a specific use case but lacks parameter details, return value information, and full behavioral context. An agent would need additional information to use 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%, and the description only provides meaning for calculationName (via the usage instruction). Other parameters like jobId, gateway, status, etc., are not explained. The description adds minimal value beyond the schema.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Purpose4/5
Does the description clearly state what the tool does and how it differs from similar tools?
The description clearly states the tool records a Materials Studio Job Control receipt and specifies the context: for native_castep preparation, call after submitting XSD. It gives a specific verb and resource, but doesn't explicitly differentiate from sibling tools like ms_remote_castep_batch_status, though the purpose is distinct.
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 explicit usage guidance: call once per calculationName after submitting XSD. It clearly indicates when to use the tool but does not mention exclusions or alternatives. This is still effective for an 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?
Description implies a read-only, side-effect-free operation but does not confirm safety or disclose any behavioral traits; no annotations to compensate.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Conciseness5/5
Is the description appropriately sized, front-loaded, and free of redundancy?
Single sentence with no wasted words, front-loaded 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?
Sufficient for a simple tool with no parameters or output schema, but could hint at snippet format or usage context.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Parameters4/5
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
No parameters exist, so description adds no param info; baseline for 0 params is 4.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Purpose5/5
Does the description clearly state what the tool does and how it differs from similar tools?
Description clearly states the tool returns an MCP server config snippet for Codex settings, distinct from sibling tools that focus on MS 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?
No guidance on when or why to use this tool over alternatives; no context provided for integration with Codex settings.
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 provided; description mentions 'using MaterialsScript' but does not disclose behavioral traits like side effects, permissions, or whether it modifies existing documents. Minimal behavioral context beyond the basic action.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Conciseness5/5
Is the description appropriately sized, front-loaded, and free of redundancy?
Two efficient sentences: first states purpose, second provides usage guidance. No fluff or 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 no output schema, no annotations, and 4 parameters, the description is too brief. It explains the tool's purpose and when to use alternatives, but lacks detail on return values, parameter behavior, and potential constraints.
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% parameter description coverage; the description does not explain individual parameters. It implicitly mentions atoms and bonds but provides no details on formatting, constraints, or how they are used.
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?
Clearly states the tool creates a standalone molecule/crystal document from explicit atoms and bonds using MaterialsScript. Distinguishes from sibling tool ms_gui_create_current by specifying it creates a standalone document, not in the GUI.
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?
Explicitly advises to prefer ms_gui_create_current when working within an open GUI project to avoid duplicate documents, providing clear guidance on when to use this tool vs. alternatives.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Behavior3/5
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
No annotations are provided, so the description carries the burden. It states the tool retrieves information (a read operation) but does not disclose any behavioral traits such as side effects, performance implications, or prerequisites. The description is accurate 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.
Conciseness4/5
Is the description appropriately sized, front-loaded, and free of redundancy?
The description is a single, front-loaded sentence that efficiently conveys the core purpose. It is concise but could be slightly expanded to clarify what 'history' entails. Still, it earns its place 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?
The description lists what the tool returns but does not provide details on the return format or structure, and there is no output schema. For a tool that aggregates multiple state pieces, more completeness would be beneficial. Among sibling tools, it is a query tool, but the description leaves some ambiguity.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Parameters4/5
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
The input schema has no parameters (empty properties), and schema description coverage is 100% (trivially). With no parameters, the description does not need to add meaning beyond what the schema provides. Baseline score of 4 is appropriate.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Purpose5/5
Does the description clearly state what the tool does and how it differs from similar tools?
The description clearly identifies the tool's purpose: retrieving the stateful GUI session target, listing specific elements (current document, exported file, last job, history). It distinguishes itself from sibling tools that perform actions on the GUI state.
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 using the tool to query GUI state, but provides no explicit guidance on when to use it versus alternatives like ms_gui_apply_current or ms_gui_edit_current. There are no usage conditions or exclusions 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 should disclose behavioral traits. It says 'create or replace' implying mutation of the current document, but doesn't elaborate on side effects (e.g., overwriting existing content), permissions, or undo capabilities. It mentions the vacuum constraint, but lacks depth on other behaviors like forceNew or coordination type handling.
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 three sentences, each serving a distinct purpose: defining the action, providing usage priority, and setting a boundary. There is no redundancy or filler. It is front-loaded with the core purpose.
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 complexity (17 parameters, no output schema, no annotations), the description is insufficient for complete agent understanding. It omits guidance on critical parameters like coordinate types, bond calculation, space group, and output handling. A more comprehensive description would cover these or reference documentation.
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 low (29%), so the description should add meaning for undocumented parameters. However, it only provides general context about vacuum and CIF alternatives, not explaining key params like a, b, c, atoms, coordinateType, spaceGroup, etc. This leaves agents guessing about parameter usage beyond what the schema provides.
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 'Create or replace the current GUI document as a periodic crystal/unit cell from lattice parameters and atom coordinates.' It specifies the resource (GUI document) and action (create/replace), and distinguishes from siblings like ms_gui_find_cif_import_current by directing users to that tool first.
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?
The description explicitly advises to first try ms_gui_find_cif_import_current for new crystals, and to only use manual construction when no CIF is found or user provides credentials. It also warns against adding vacuum unless explicitly requested. This provides clear when-to-use and 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?
The description implies a read-only check but does not explicitly state whether it modifies state, requires authentication, or has side effects. With no annotations provided, the description carries the full burden, and it partially fulfills it by indicating 'check' but lacks detail.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Conciseness5/5
Is the description appropriately sized, front-loaded, and free of redundancy?
Single, clear sentence front-loading the action and scope. No unnecessary words; every part earns its place.
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 status check with no parameters and no output schema, the description adequately covers the tool's function. It could detail return format or behavior, but contextually it 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 input schema has zero parameters, so baseline is 4. The description adds meaning beyond the schema by specifying what the tool checks (paths, availability, workspace), which is sufficient for a parameterless 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 explicitly states the tool checks three specific aspects: Materials Studio paths, RunMatScript availability, and MS-MCP workspace. This clearly distinguishes it from sibling tools that perform actions like running scripts, queue management, or GUI operations.
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 guidance on when to use this tool versus alternatives. However, the purpose implies it serves as a pre-check before other MS operations, so usage context is somewhat implied but not stated.
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 full burden. It discloses that by default the tool reuses existing documents to avoid duplicates, and that it can replace the current document. However, it does not explicitly mention side effects like overwriting without confirmation or error handling.
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 three concise sentences: purpose, usage guidance, then default behavior. No redundant information, and critical guidance 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?
Given the tool has 5 parameters, no output schema, and no annotations, the description leaves gaps: it does not describe return values, validate the body input beyond mentioning it, or explain exportFile and ballAndStick behavior. More detail on outcomes and error cases would improve 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?
Schema description coverage is only 40%, but the description adds significant value: it explains that the body parameter should be a MaterialsScript with a pre-created $doc variable, and implies the forceNew parameter's effect by describing default reuse. However, exportFile and ballAndStick parameters are not elaborated.
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 ('Create or replace'), resource ('current GUI document'), and input ('MaterialsScript body'). It distinguishes from sibling tools like ms_gui_find_cif_import_current by recommending that for new structures.
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 guidance is provided: before using for a new structure, try ms_gui_find_cif_import_current first; use this tool only when no reliable open CIF or user credentials are available. This helps the agent decide when to invoke this tool versus alternatives.
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:

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

Score Badge

Copy to your README.md:

[![MS-MCP MCP server](https://glama.ai/mcp/servers/DrYe1109/MS-MCP/badges/score.svg)](https://glama.ai/mcp/servers/DrYe1109/MS-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/DrYe1109/MS-MCP'

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