materials-studio-mcp-moc

Server Quality Checklist

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

Latest release: v0.1.0
Disambiguation2/5
Many tools have overlapping purposes, such as multiple preflight/check/validate tools (md_structure_preflight, ms_castep_fixed_profile_preflight, ms_castep_preflight_checked, md_msi2lmp_preflight) and several prepare/build tools. The distinction between 'preflight', 'checked', and 'readiness' tools is not clear from names, causing potential misselection.
Naming Consistency2/5
Tool names mix conventions: some use verb_noun (md_task_submit), others use noun_noun (ms_castep_gateway_readiness), and prefixes vary between ms_, md_, and combinations. Verbs like get, check, assess, plan, prepare, and run are used inconsistently, making the naming pattern unpredictable.
Tool Count2/5
With 53 tools, the server is over 25, which is excessive for most MCP servers. While the domain is complex, many tools are highly specialized and could be consolidated (e.g., multiple preflight and checked variants), making the surface feel bloated.
Completeness4/5
The tool set covers the core lifecycle of Materials Studio workflows, including project initialization, structure preparation, conversion, validation, task management, and quality gates. Minor gaps exist, such as no generic list projects or delete artifact tools, but agents can work around these via existing project_get and register_artifact.
Average 3/5 across 53 of 53 tools scored. Lowest: 2/5.
See the Tool Scores section below for per-tool breakdowns.
- No community issues in the last 6 months
- 21 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
Add a LICENSE file by following GitHub's guide. Once GitHub recognizes the license, the system will automatically detect it within a few hours.
If the license does not appear after some time, you can manually trigger a new scan using the MCP server admin interface.
MCP servers without a LICENSE cannot be installed.
This repository includes a README.md file.
No tool usage detected in the last 30 days. Usage tracking helps demonstrate server value.
Tip: use the "Try in Browser" feature on the server page to seed initial usage.
Add a glama.json file to provide metadata about your server.
If you are the author, simply .
If the server belongs to an organization, first add glama.json to the root of your repository:
```
{
  "$schema": "https://glama.ai/mcp/schemas/server.json",
  "maintainers": [
    "your-github-username"
  ]
}
```
Then . Browse examples.
Add related servers to improve discoverability.

How to sync the server with GitHub?

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

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

How is the quality score calculated?

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

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

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

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

Tool Scores

Behavior1/5
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
With no annotations provided, the description carries the full burden of disclosing side effects and safety behavior. It only says 'Convert' and mentions 'hash-bound', implying integrity checks, but it does not state whether the tool writes files, modifies the project, requires confirmation, or is irreversible. The presence of confirmation_token, idempotency_key, and dry_run parameters hints at safety mechanisms, but the description ignores them entirely.
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, grammatically complete sentence with no wasted words, and the verb 'Convert' is front-loaded. However, it is under-specified for a tool of this complexity; it lacks any sub-clauses or structure to convey important context, making it feel sparse rather than effectively concise. It is better than a tautology but still not sufficiently informative.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Completeness1/5
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
The tool has 13 parameters, 10 required, and includes security-sensitive fields like hashes, confirmation_token, and idempotency_key. The description provides almost no operational context, such as what triggers this conversion, what the output is used for, or what checks are performed. Even if an output schema exists, the description still fails to give the agent enough information to decide when and how to use the tool.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Parameters1/5
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
Schema description coverage is 0%, so the description must compensate by explaining at least the key parameters. It does not explain project_directory, car_path, mdf_path, forcefield_file, output_slot, hashes, dry_run, timeout_seconds, forcefield_class, confirmation_token, or idempotency_key. The only hint is 'CAR/MDF pair' and 'forcefield', which map to some file parameters but add no real semantic value beyond the schema titles.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Purpose4/5
Does the description clearly state what the tool does and how it differs from similar tools?
The description states the tool converts a CAR/MDF pair with a forcefield, which clearly identifies the action and the resources involved. However, the output format (LAMMPS) is only implied by the tool name, not stated in the description, and the phrase 'hash-bound' is ambiguous to someone unfamiliar with the workflow. It does distinguish from sibling tools like md_export_xsd_to_car_mdf_checked, which handles the reverse conversion, but the description alone doesn't fully clarify the tool's role.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Usage Guidelines1/5
Does the description explain when to use this tool, when not to, or what alternatives exist?
The description gives no guidance on when to use this tool, what prerequisites are needed (e.g., a valid project directory, hash-bound files), or what steps precede or follow it. It does not mention alternatives or exclusions, and there is no context about workflow integration. This is a critical gap for a tool with many sibling tools.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Behavior2/5
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
With no annotations, the description must disclose side effects, but it does not. It lacks any mention of mutations, dry-run behavior (which is in schema), permissions, or what an 'audited' and 'legal' transition entails.
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, but it is under-specified; it omits critical information and uses unclear terminology. It is concise in length but not in substance.
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 5 parameters, no annotations, and no schema descriptions, the description is grossly insufficient. It fails to explain what the tool does, when to use it, or what the implications of a transition are.
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% and the description does not explain any parameters (project_directory, target_status, reason, dry_run, evidence_ids). It also doesn't clarify what constitutes a 'legal' transition or valid target_status values.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Purpose3/5
Does the description clearly state what the tool does and how it differs from similar tools?
The description states it 'applies one audited, legal project lifecycle transition' but uses vague jargon ('audited', 'legal', 'v1 result envelope') without explaining what the transition does. It does not clearly distinguish from siblings like md_project_set_quality_gate or md_project_validate.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Usage Guidelines2/5
Does the description explain when to use this tool, when not to, or what alternatives exist?
No guidance is provided about when to use this tool vs alternatives. There is no mention of preconditions, alternatives, or exclusion cases.
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 behavior. It vaguely mentions impacting a 'fixed worker process tree' but doesn't clarify whether cancellation is destructive, whether confirmation is needed, or what 'plan' means.
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, which is concise, but it sacrifices clarity for brevity. It is short and front-loaded, but not effective.
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 no parameter documentation and no usage context, the description is insufficient for an agent to invoke this tool correctly. The presence of an output schema doesn't compensate for the missing behavioral and parameter details.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Parameters1/5
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
Schema description coverage is 0%, and the description provides no explanation of task_id, owner_capability, dry_run, or confirmation_token. It only implies ownership but leaves the rest ambiguous.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Purpose3/5
Does the description clearly state what the tool does and how it differs from similar tools?
The description mentions 'Plan or cancel one owned task and its fixed worker process tree,' but the verb is ambiguous ('Plan' or 'cancel') and doesn't clearly distinguish from sibling task tools like md_task_submit or md_task_query. It identifies a resource (owned task) but the action is muddled.
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 md_task_retry or md_task_submit. It doesn't indicate prerequisites or scenarios where cancellation is appropriate.
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 behavior, but it only reveals that MatServer execution stops before CASTEP. It does not explain what constitutes success/failure, whether anything is modified, or the role of confirmation_token. This leaves the tool's operational behavior largely opaque.
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, which is efficient, but the phrasing 'one exact generated CASTEP PL' is awkward and the sentence lacks structure to convey key context. It is concise but at the expense of clarity.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Completeness1/5
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
The tool has 6 parameters, no annotations, and no parameter descriptions, yet the description provides no return value information, no parameter semantics, and no operational details. Despite having an output schema, the description alone is far from sufficient for an agent to invoke 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%, and the description adds no parameter explanations. The six input parameters (package_directory, package_manifest_sha256, task_name, dry_run, timeout_seconds, confirmation_token) are undocumented in both schema and description, making it impossible to understand what values to provide.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Purpose4/5
Does the description clearly state what the tool does and how it differs from similar tools?
The description states the tool runs a generated CASTEP PL through MatServer and exits before CASTEP, giving a specific verb and resource. It distinguishes itself from preparation tools like ms_prepare_castep_pl_package by focusing on preflight execution, though it does not explicitly contrast with other preflight 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 is provided on when to use this tool versus alternatives. The phrase 'exit before CASTEP' implies a validation use case, but there is no explicit mention of prerequisites, scenarios, or comparison to sibling preflight tools like ms_castep_fixed_profile_preflight or ms_castep_gateway_readiness.
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 implies a mutation operation ('Place') but does not disclose effects, idempotency, reversibility, or whether the ledger review is a mandatory precondition. The idempotency_key parameter is not mentioned, and the operation's impact on the existing structure is unclear.
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, efficient sentence with no redundancy, which is positive. However, given the tool's complexity (12 parameters, no annotations), this is under-specification rather than appropriately sized. It is not as extreme as a tautology, but lacks necessary detail.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Completeness1/5
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
The tool has 12 parameters, no annotations, and an output schema that is not described. The description provides no workflow context, prerequisites, or guidance on how this fits into the broader pipeline (as seen in sibling tools). It is insufficient for an agent to select and invoke 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%, and the description provides no information about any of the 12 parameters (e.g., placements, min distances, output_slot, max_atoms). The only vague hint is 'reviewed P1 fractional-coordinate ledger', which could relate to input_structure or placements but is not mapped explicitly.
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 ('Place explicit counterions') and the source ('a reviewed P1 fractional-coordinate ledger'), which conveys a specific scope. However, it does not explicitly differentiate this from sibling geology tools like ms_geology_apply_substitutions or ms_geology_apply_hydroxylation_ledger, beyond the mention of the ledger.
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, nor any mention of prerequisites, expected inputs, or exclusions. The 'reviewed ledger' implies a prior review step, but this is not elaborated.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Behavior2/5
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
With no annotations, the description carries the full burden of behavioral disclosure. It fails to explain what side effects 'opening' a document has, whether it modifies state, requires confirmation, or how the dry run and confirmation_token interact. The idempotency_key suggests retry semantics, but this is not disclosed.
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 front-loads the core purpose, which is good for conciseness. However, it is under-specified for a tool with six parameters and no other explanatory structure, making it too terse to be genuinely helpful.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Completeness2/5
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
Despite having an output schema, the description lacks essential context about the dry-run flow, confirmation token usage, idempotency behavior, and what the tool actually returns or changes. The complexity of six parameters and a security-oriented 'hash-bound' requirement demands more explanation than this one sentence provides.
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 adds almost no parameter meaning beyond listing 'optional dry run'. The six parameters (project_directory, document_path, document_sha256, idempotency_key, dry_run, confirmation_token) are not explained, leaving the agent to guess the format, purpose, and validation rules for each.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Purpose4/5
Does the description clearly state what the tool does and how it differs from similar tools?
The description states a specific action ('Open') and a specific resource ('one hash-bound project document through MOC'), which distinguishes it from the broad sibling list. However, it does not clarify what 'open' means in this MOC context (e.g., returns content, marks as opened), leaving some ambiguity.
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 mentions 'after an optional dry run' but provides no explicit guidance on when to use this tool versus siblings like ms_inspect_document or other MOC tools. No exclusions, prerequisites, or alternative tool references are given, so the usage context is only implied.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Behavior1/5
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
No annotations are present, so the description must disclose side effects, validation behavior, and safety traits, but it only states the output type. It fails to mention dry_run defaulting, confirmation_token requirements, checksum validation, or that it writes to output_slot.
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 fluff, and the core action and artifact are front-loaded. However, given tool complexity, a longer structured description would be more appropriate, so it doesn't earn a 5.
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 tool with 18 required parameters, no annotations, and sibling workflow dependencies, one sentence does not provide enough context. It doesn't indicate where this step fits in the pipeline, what the output candidate is used for, or how to handle the many integrity-related inputs.
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 names none of the 20 parameters. It does not explain required inputs such as input_packed_structure, packing_receipt_path, force field files, or idempotency_key, nor how they relate to each other.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Purpose5/5
Does the description clearly state what the tool does and how it differs from similar tools?
Description uses specific action 'Generate' with a precise artifact: an exact-count, neutral quartz ClayFF/SPC/E/Joung LAMMPS candidate. This distinguishes it from sibling packing/slab-building tools like ms_pack_periodic_aqueous_nacl and ms_geology_build_periodic_slab_cell.
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 invoke this tool versus alternatives or in what workflow order (e.g., after packing, before LAMMPS run). With sibling tools for packing and building, the absence of explicit selection criteria leaves 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?
With no annotations, the description must disclose behavior. It only hints at safety by mentioning 'nonproduction candidate' but omits side effects, permission requirements, irreversibility, or the roles of dry_run and confirmation_token.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Conciseness4/5
Is the description appropriately sized, front-loaded, and free of redundancy?
The description is a single concise sentence that front-loads the primary purpose. It is easy to parse, but the brevity comes at the cost of missing crucial information.
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 tool with 9 parameters, 6 required, and no annotations, a one-sentence description is inadequate. It lacks practical context about workflows, dry-run semantics, idempotency, or confirmation steps, making it insufficient for reliable agent use.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Parameters1/5
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
Schema description coverage is 0%, and the description does not explain any parameters. Terms like 'substitutions', 'confirmation_token', and 'idempotency_key' remain undefined, so the description adds negligible value to 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 identifies the action (Apply), the resource (P1 substitution ledger), and the result (return a nonproduction candidate). It distinguishes itself from sibling tools like ms_geology_apply_hydroxylation_ledger by specifying P1 substitutions.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Usage Guidelines1/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 or which alternatives might be more appropriate. The description does not mention contexts, prerequisites, or exclusion scenarios.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Behavior2/5
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
With no annotations provided, the description carries the full burden of disclosing behavior. It mentions 'audited' and 'local API' but does not explain side effects, required permissions, whether the operation is destructive, or what 'audited' entails. For a tool with confirmation_token and idempotency_key parameters, 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.
Conciseness2/5
Is the description appropriately sized, front-loaded, and free of redundancy?
The description is a single sentence with no wasted words, but it is severely under-specified for a tool with 12 parameters and 9 required fields. Conciseness is good, but the brevity reflects under-specification rather than efficient coverage of essential information.
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?
Despite having an output schema, the tool has 12 parameters, no schema descriptions, no annotations, and a one-sentence description. The agent lacks essential context about parameter relationships, preconditions, output validity, or failure modes, making the description completely inadequate 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%, and the description provides no parameter meanings. It does not mention repeat dimensions, max_atoms, project_directory, or any other parameter. The agent cannot infer parameter semantics from either the schema or the description.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Purpose5/5
Does the description clearly state what the tool does and how it differs from similar tools?
The description clearly states the action ('Build'), the object ('one audited XSD supercell'), and the method ('local MS 2023 BuildSuperCell API'). It effectively distinguishes from sibling tools like ms_geology_build_periodic_slab_cell by specifying the XSD supercell output and the audited nature.
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_geology_build_periodic_slab_cell or other build/preflight tools. There are no exclusions, prerequisites, or contextual hints about the intended workflow.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Behavior2/5
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
No annotations are provided, so the description carries the full burden. It discloses 'read-only' (safe), but says nothing about what the assessment actually checks, what it returns, whether it reads local files, or any other behavioral traits. The single phrase 'read-only' is insufficient for a tool with 2 parameters and nested objects.
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 very concise and front-loaded, but under-specified. It is a single sentence with no waste, yet it sacrifices necessary detail for brevity, making it inadequately sized for the tool's complexity.
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 an output schema, 2 parameters (one nested object), and no annotations, the description is far from complete. It does not explain the purpose of search_roots, the nature of the assessment, criteria used, or the output content. The context provided by sibling tools suggests a rich domain, but this description provides none of that context.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Parameters2/5
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
Schema description coverage is 0%. The description implies 'model_spec' via 'model specification' but does not explicitly describe either parameter, and 'search_roots' is completely unaddressed. The description adds minimal meaning beyond the schema's raw parameter names.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Purpose4/5
Does the description clearly state what the tool does and how it differs from similar tools?
The description clearly identifies the tool as a read-only intake assessment for an incomplete Materials Studio model specification. It specifies the resource ('model specification') and implies the action (assess), which distinguishes it somewhat from sibling readiness/preflight 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?
No guidance is given on when to use this tool versus alternatives. There is no mention of prerequisites, exclusions, or comparisons with sibling tools, 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?
There are no annotations, so the description must fully disclose behavioral traits. It lists validation targets but does not state whether the operation is read-only, whether it modifies files, or what side effects (if any) occur. A validation tool is typically expected to be non-destructive, but the description does not confirm this, leaving the agent in doubt.
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 communicates the validation targets in a clean list. It avoids filler or redundancy, though it could benefit from a brief usage hint without losing conciseness.
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 minimal: it states what is validated but not how validation is performed, what happens on failure, or when in a project lifecycle this should be invoked. Although an output schema exists, the description itself does not orient the agent on prerequisites, side effects, or expected outcome, leaving significant gaps for a validation tool in a complex domain.
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 only parameter, project_directory, has zero schema description coverage (0%), and the tool description does not mention it at all. The agent receives no guidance on whether the path must be absolute, relative, existing, or what format is expected. With such minimal information, the parameter semantics are severely under-documented.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Purpose4/5
Does the description clearly state what the tool does and how it differs from similar tools?
The description uses a specific verb 'Validate' and enumerates four distinct aspects (project structure, model specification, forcefield declaration, registered file integrity), making the primary purpose clear. It is distinct from sibling preflight tools that focus on specific formats (e.g., ms_castep_preflight_checked), though it does not explicitly compare itself to them.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Usage Guidelines2/5
Does the description explain when to use this tool, when not to, or what alternatives exist?
The description provides no explicit context for when to use this tool or how it relates to alternatives like md_project_initialize or md_structure_preflight. The only indication is the tool's name and general 'validate' intent, which is not sufficient to guide an agent on choosing this over similar tools.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Behavior2/5
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
With no annotations provided, the description carries the full burden. It discloses that the tool does not select or repair a termination, but it does not explain side effects, whether files are created, whether confirmation_token is needed, or how dry_run behaves. The presence of task-related parameters (idempotency_key, timeout_seconds) suggests a possibly long-running or irreversible operation, but the description remains silent.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Conciseness5/5
Is the description appropriately sized, front-loaded, and free of redundancy?
The description is a single, compact sentence with no fluff. It front-loads the verb and resource, making it easy to scan. However, its brevity is detrimental to semantic completeness, but that is a completeness issue, not a conciseness one.
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?
Despite the tool having 16 parameters, 11 required, and a non-trivial domain (surface termination enumeration), the description gives no context on how to prepare inputs, what the output will be, or how it fits in a larger workflow. The output schema exists but is not shown, and the one-sentence description is insufficient for an agent to invoke this 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?
The input schema has 16 parameters with no descriptions (0% coverage), and the description does not explain any of them. Required parameters like input_bulk_structure, top_positions, and output_slot are completely undefined. The description provides zero help in filling the arguments.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Purpose4/5
Does the description clearly state what the tool does and how it differs from similar tools?
The description uses a specific verb ('Enumerate') and resource ('nonproduction surface candidates'), and clarifies that it does not select or repair a termination, which helps distinguish it from a selection/repair step. However, it does not name a sibling tool or explicitly state what is produced, leaving some ambiguity about the exact output.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Usage Guidelines2/5
Does the description explain when to use this tool, when not to, or what alternatives exist?
No guidance is given on when to use this tool versus alternatives like ms_geology_build_periodic_slab_cell. The phrase 'without selecting or repairing' implies a pre-selection step, but there is no explicit when-to-use or exclusion. Prerequisites are not 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?
With no annotations provided, the description carries the full burden. 'Hash-bound, confirmed MaterialsScript run' hints at a security/confirmation workflow but doesn't specify what side effects or guarantees exist, what 'confirmed' entails, or what the output represents. Lacks transparency about 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?
One sentence is concise, but it packs in vague jargon ('hash-bound, confirmed MaterialsScript run') that obscures rather than informs. While there's no wasted words, the lack of elaboration makes it under-specified rather than cleanly written.
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 7 parameters and an output schema, this description is incomplete. It doesn't define 'analysis targets', the meaning of the confirmation hash, or the conditions under which the tool is used. The output schema exists, so return format is covered, but the operational context is missing.
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 7 parameters with zero descriptions, and the description doesn't mention them explicitly. The phrase 'hash-bound' suggests input_sha256 is a hash of input_document, and 'confirmed' implies confirmation_token, but this is only a hint and leaves dry_run, job_name, keep_job_dir, timeout_seconds entirely unexplained. Does not compensate for the 0% 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?
States 'List analysis targets' clearly as a list operation on a specific resource, distinguishing it from sibling tools like ms_list_example_documents. However, the phrase 'hash-bound, confirmed MaterialsScript run' adds jargon without explaining what analysis targets are or the nature of the run, slightly obscuring clarity.
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?
Provides no guidance on when to use this tool versus alternatives, no prerequisites, and no context about the verification or hash requirement. Only states what it does, not when it's appropriate.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Behavior2/5
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
No annotations are provided, so the description carries the full burden of behavioral disclosure. It names the workflow steps (MS, LAMMPS, VMD) but does not disclose side effects, input/output behavior, prerequisites, failure modes, or safety aspects. The description adds only minimal context beyond the tool name.
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 front-loaded and contains no filler. It is appropriately concise, though it could add a bit more detail without becoming verbose. The structure is clear and easy to skim.
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 tool with 14 parameters, 0% schema coverage, no annotations, and no explanation of outputs or side effects, the description is severely incomplete. An output schema exists but is not referenced in the description, and the agent has no way to understand the tool's workflow behavior, parameter meanings, or proper use 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 0%, and the description provides no information about any of the 14 parameters. The schema itself only has parameter titles and defaults, which are not self-explanatory for many parameters like 'input_sha256' or 'forcefield_off'. The description fails to compensate for the lack of 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 a specific action ('Run'), a specific resource ('bounded G01 MS -> LAMMPS -> VMD qualification workflow'), and the scope ('only'). It distinguishes itself from sibling tools by naming the exact pipeline and bounded nature, which is more specific than generic workflow names.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Usage Guidelines2/5
Does the description explain when to use this tool, when not to, or what alternatives exist?
No explicit guidance is given on when to use this tool versus alternatives. The word 'only' implies it should be used for this specific bounded workflow, but there is no mention of when not to use it or which sibling tools might be preferred for other scenarios.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Behavior2/5
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
With no annotations, the description must carry the full burden of behavioral disclosure. It reveals that the tool replaces and merges (mutating behavior), but omits important behaviors like the default dry_run=true, idempotency support, and the scope of what gets destroyed or overwritten.
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 conveys the core purpose without wasted words. It is concise, though perhaps too terse given the complexity of the tool.
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 7-parameter tool with nested objects and an output schema, this description leaves significant gaps: no mention of required arguments, workflow timing, side effects, dry-run behavior, or return information. The presence of an output schema does not compensate for the lack of usage context.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Parameters2/5
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
Schema description coverage is 0%, so the description must compensate by explaining parameters. It loosely maps to science_contract, forcefield, and geology_model via 'science contract' and 'model/forcefield/geology requirements,' but it does not clarify the required project_directory and specification, nor the dry_run or idempotency_key parameters.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Purpose4/5
Does the description clearly state what the tool does and how it differs from similar tools?
The description states a specific action—'Replace the science contract and merge confirmed model/forcefield/geology requirements'—with a clear verb and resource. It is understandable but does not explicitly differentiate from sibling project-management tools like md_project_validate or md_project_set_quality_gate.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Usage Guidelines2/5
Does the description explain when to use this tool, when not to, or what alternatives exist?
No guidance is given about when to call this tool versus alternatives such as md_project_initialize, md_project_validate, or md_project_transition. The word 'confirmed' hints at a prerequisite, but there is no explicit workflow context, exclusions, or alternative recommendations.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Behavior2/5
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
With no annotations provided, the description carries the full burden of behavioral disclosure. It mentions 'preflight' and 'asynchronously submit,' but does not explain side effects, permissions, confirmation token requirements, or what happens if preflight fails. This is minimal behavioral context for a tool that likely triggers operations.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Conciseness4/5
Is the description appropriately sized, front-loaded, and free of redundancy?
The description is a single, front-loaded sentence with no wasted words. It is appropriately concise for a high-level overview, though it sacrifices necessary detail for brevity.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Completeness2/5
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
Despite the presence of an output schema and 4 parameters, the one-line description leaves critical gaps: what does 'governed operation' mean, how does dry_run work, when is confirmation_token required, and how does asynchronous submission behave? The description is inadequate for correct tool 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?
The description does not reference any of the four parameters (tool_name, parameters, dry_run, confirmation_token). With 0% schema description coverage, the description should compensate by clarifying how these parameters are used, but it provides no such information.
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 'Preflight and asynchronously submit one exact governed operation,' which clearly identifies the action (submit) and resource (one exact governed operation). It distinguishes from sibling tools like md_task_query, md_task_cancel, and md_task_retry by emphasizing submission rather than status, cancellation, or retry.
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 explicit guidance on when to use this tool versus alternatives. It does not mention prerequisites, exclusions, or scenarios where query/cancel/retry would be more appropriate. The 'preflight' aspect implies a validation step but lacks concrete 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 must carry the full burden of disclosing behavioral traits. 'Find' implies a read-only operation, but it does not explicitly state whether it modifies anything, whether it requires an installation, or what it returns. The description lacks necessary behavioral context beyond the verb.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Conciseness4/5
Is the description appropriately sized, front-loaded, and free of redundancy?
The description is a single, front-loaded sentence with no wasted words. It is concise and grammatically direct, earning its place. While it could benefit from more detail, the conciseness dimension rewards efficiency, and this description is appropriately brief.
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 two parameters and an output schema, the description is incomplete. It does not clarify the scope of 'local' (e.g., installed files), how results are presented, or how this tool relates to sibling example-listing tools. The output schema mitigates some need for return value details, but critical usage context remains missing.
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 adds almost no meaning to the parameters. It references 'query' generically but does not explain the expected format, how 'max_results' affects output, or any semantics beyond the schema's bare type/default. The description fails to compensate for the low 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 action ('Find') and resource ('local Materials Studio scripting code examples'), with scope ('relevant to a query'). While it does not explicitly differentiate from sibling tools like ms_list_example_documents or ms_search_local_help, the resource type is specific enough to infer its distinct purpose.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Usage Guidelines3/5
Does the description explain when to use this tool, when not to, or what alternatives exist?
The phrase 'relevant to a query' implies this tool is for query-based retrieval, suggesting usage when a user has a specific need. However, there is no explicit guidance on when to use this over alternatives, nor any exclusion criteria or references to sibling tools.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Behavior2/5
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
No annotations are provided, so the description carries full responsibility for behavioral disclosure. It only states 'convert' without explaining side effects, prerequisites like what 'reviewed' means, the hashing mechanism, or whether the operation is destructive or requires confirmation. This is insufficient for a mutation-like tool.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Conciseness5/5
Is the description appropriately sized, front-loaded, and free of redundancy?
The description is a single, focused sentence with no filler words. It immediately states the purpose and is well-structured for quick reading.
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 (12 parameters, 9 required, no schema descriptions, no annotations), a one-sentence description is severely inadequate. It does not explain the workflow, the meaning of key terms, how to set required parameters, or what the output contains. The agent cannot reliably invoke this 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?
The schema has 0% description coverage, and the description does not compensate by explaining any of the 12 parameters. Terms like vacuum_thickness_angstrom and expected_total_c_angstrom are left entirely to the agent's interpretation, and the description's mention of 'hash-bound' gives no parameter-level guidance.
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 'Convert' and the resource: a reviewed 2D surface to a hash-bound 3D periodic slab cell. This distinguishes it from siblings like ms_geology_build_supercell, which focuses on supercell construction rather than slab cell conversion.
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 explicit guidance on when to use this tool versus alternatives. The description implies the input is a reviewed 2D surface, but it does not mention when to choose this over similar tools such as ms_geology_build_supercell or ms_pack_periodic_aqueous_nacl, nor any exclusions.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Behavior2/5
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
With no annotations, the description does not disclose side effects, whether it writes to disk, the meaning of 'hash-bound', or any constraints; it merely restates an action without behavioral 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?
One short sentence, front-loaded with the action verb, no filler; it is minimal but effective in structure.
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?
Despite 21 parameters and a complex operation, the description is only 10 words and fails to explain the package structure, the role of the adaptive plan, or how inputs like input_xsd and spins relate to the task; an output schema exists but cannot substitute for usage 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?
The description does not explain any of the 21 parameters, and schema coverage is 0%, leaving the agent to infer meaning from names alone; for a tool with 5 required parameters, this is a significant gap.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Purpose4/5
Does the description clearly state what the tool does and how it differs from similar tools?
The description uses a specific verb 'prepare' and names the resource 'hash-bound CASTEP PL/XSD folders', making the core function clear. However, it does not differentiate from sibling tools like ms_prepare_castep_standalone_inputs, which could cause selection ambiguity.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Usage Guidelines3/5
Does the description explain when to use this tool, when not to, or what alternatives exist?
The description implies usage context (preparing CASTEP package folders) but provides no explicit guidance on when to choose this over similar prepare tools, 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?
With no annotations, the description carries the full burden. It implies a write operation but does not disclose persistence behavior, idempotency, the effect of the 'dry_run' parameter (defaulting to true), or any potential side effects such as overwriting existing data.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Conciseness4/5
Is the description appropriately sized, front-loaded, and free of redundancy?
The description is a single concise sentence with no redundant phrasing. However, its extreme brevity sacrifices necessary detail, preventing a higher score for structure.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Completeness2/5
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
Given the tool's complexity—5 parameters, zero schema descriptions, no annotations, though an output schema exists—the description is far too sparse. It omits critical context such as dry_run behavior, evidence schema expectations, and gate/status semantics, making safe invocation difficult.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Parameters2/5
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
Schema description coverage is 0%, and the description does not compensate. It only vaguely refers to 'quality-gate decision' and 'structured evidence' but fails to explain the meaning or allowed values of gate, status, evidence, dry_run, and project_directory beyond their schema types.
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 'Record' and the specific resource: a quality-gate decision and structured evidence, with the target being the project manifest. This distinguishes it from sibling tools that handle other project aspects like registration, validation, or transitions.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Usage Guidelines2/5
Does the description explain when to use this tool, when not to, or what alternatives exist?
No guidance is provided on when to use this tool versus alternatives. There are no mentions of prerequisites, project state conditions, or situations where this tool should be preferred over similar project management operations.
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 must carry the full burden of behavioral disclosure. It states only that the tool protonates sites, but does not disclose that this is a mutation operation, whether a dry_run or confirmation_token is involved (despite their presence in the schema), or any side effects on the structure or ledger. The description lacks detail on safety, reversibility, or required permissions.
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 of 11 words, front-loading the key action and target. There is no filler, repetition, or redundant information. Every word contributes to the core meaning, making it highly efficient.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Completeness2/5
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
Given the tool's complexity (14 parameters, 10 required, no annotations, no schema descriptions), the description is far too sparse. It provides the basic operation but omits critical context like the nature of the ledger, how sites are identified, what constraints apply (bond lengths, distances, max atoms), and what state changes occur. Even with an output schema, this is insufficient for an agent to understand the tool's full requirements and behavior.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Parameters1/5
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
The schema has 14 parameters with 0% description coverage, and the description provides no parameter-level meaning. The only parameter hinted at is 'sites' via 'explicit ledger', but the description does not explain the structure of the ledger or the meaning of the bond length, distance, charge, or idempotency parameters. With such low schema coverage, the description needed to compensate but did not.
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 'protonate' and names a precise resource: 'an explicit ledger of singly Si-coordinated O sites in a 2D p1 surface.' This clearly distinguishes it from sibling geology tools like ms_geology_apply_substitutions or ms_geology_place_counterions, which perform different modifications.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Usage Guidelines2/5
Does the description explain when to use this tool, when not to, or what alternatives exist?
No guidance is given on when to use this tool versus alternatives. It does not mention the distinction between this, substitutions, or counterion placement, nor does it specify preconditions such as the need for a prior structure with identified sites. The description simply states the action with no contextual 'when to use' or 'if you need X, use Y' guidance.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Behavior2/5
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
With no annotations, the description carries the full burden of behavioral disclosure. It mentions 'verify' but does not explain side effects (e.g., file writes), hash mismatch behavior, idempotency implications, or the need for confirmation tokens. Critical behavioral traits are left undisclosed.
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, well-structured sentence with no filler. It is front-loaded with the primary action and verification step, making it easy to parse, though it omits necessary detail.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Completeness2/5
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
Given 10 parameters, 7 required, no annotations, and an output schema, the description is far too sparse. It fails to mention prerequisites, when to use the tool, failure handling, or the importance of fields like 'confirmation_token' and 'dry_run'. The output schema exists but the description should still provide usage context.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Parameters2/5
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
Schema description coverage is 0%, so the description must compensate. While it hints that 'input_crystal_structure' is a CIF/XSD and 'expected_elements' relates to the element inventory, it leaves parameters like 'output_slot', 'max_atoms', 'idempotency_key', and 'confirmation_token' completely 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 imports a hash-bound CIF/XSD crystal parent and verifies its periodic element inventory. It uses a specific verb ('import') and resource ('crystal parent'), distinguishing it from sibling tools that build or modify structures.
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, nor are any prerequisites or exclusions mentioned. The description simply states what the tool does without contextualizing its use.
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 must disclose behavioral traits. It mentions 'best-effort metadata' which hints at potential incompleteness, but it does not explicitly state read-only behavior, side effects, or failure modes. 'Parse' implies reading, but this is implicit rather than explicit.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Conciseness5/5
Is the description appropriately sized, front-loaded, and free of redundancy?
The description is a single, well-structured sentence that front-loads the core action and purpose. Every word contributes, with no redundancy or filler.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Completeness3/5
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
For a one-parameter tool, the description provides a basic purpose, but it lacks guidance on usage and parameter semantics. The existence of an output schema reduces the need to describe return values, yet the 'best-effort' caveat and missing usage context leave the description incomplete for a new agent.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Parameters2/5
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
With 0% schema description coverage and no parameter details in the description, the single 'path' parameter is left ambiguous. The description does not clarify expected format, file vs. project, or how to specify the target.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Purpose4/5
Does the description clearly state what the tool does and how it differs from similar tools?
The description clearly states a specific verb ('Parse') and resource ('Materials Studio document or project file') and the outcome ('return best-effort metadata'). It is distinct enough from siblings like ms_moc_open_document, though it does not explicitly differentiate itself.
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 for when to use this tool versus alternatives (e.g., ms_moc_open_document, ms_scan_workspace). The description only states what it does, not the context or exclusions.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Behavior2/5
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
With no annotations, the description carries the full burden of behavioral disclosure. It only states that it searches local help, but does not mention what results look like, whether the help must be installed, read-only behavior, or any side effects. This is 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.
Conciseness5/5
Is the description appropriately sized, front-loaded, and free of redundancy?
The description is a single, front-loaded sentence that directly states the tool's function. It contains no filler or redundant information, making it highly concise and appropriately sized for a simple search tool.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Completeness3/5
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
The tool is simple and an output schema exists, which reduces the need to explain return values. However, the lack of annotations and usage guidance, combined with the large sibling list, leaves gaps in operational context. It is minimally viable but not complete.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Parameters2/5
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
Schema coverage is 0%, and the description does not explain the parameters. The verb 'search' implicitly clarifies that 'query' is the search term, but 'max_results' is entirely unexplained. The description adds minimal value beyond the parameter names.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Purpose4/5
Does the description clearly state what the tool does and how it differs from similar tools?
The description clearly specifies the action ('Search') and the resource ('the installed Materials Studio 2023 scripting help'), making the tool's purpose unmistakable. It does not explicitly differentiate from sibling tools like ms_read_local_help_page, but the combination of search verb and narrow resource scope strongly implies a distinct query-based action.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Usage Guidelines2/5
Does the description explain when to use this tool, when not to, or what alternatives exist?
No usage guidance is provided. The description does not state when to use this tool versus alternatives, nor does it offer any context on prerequisites or exclusions. The presence of many sibling search/help tools makes this gap more significant.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Behavior2/5
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
With no annotations, the description carries the burden of disclosing behavioral traits. It only says 'recommend', which suggests no side effects, but does not specify whether it executes workflows, reads files, or what 'best available' means. The lack of detail leaves ambiguity about how the recommendation is produced and whether it has 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.
Conciseness4/5
Is the description appropriately sized, front-loaded, and free of redundancy?
The description is a single, front-loaded sentence with no filler words, making it efficient. However, it is perhaps too terse for a recommendation tool with three parameters, but it earns a 4 for zero waste.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Completeness2/5
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
The tool has three parameters and an output schema, and lacks annotations. The description does not explain how the parameters affect the recommendation, what 'best available' means, or how this tool fits with sibling workflow tools. It is too sparse for a router tool that likely needs to communicate prerequisites and usage 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 0% and the description does not describe any parameters. The request parameter is obvious from the description, but input_structure and calculation_context are unexplained, and the format or use of request is 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 a specific verb (recommend) and resource (best available Materials Studio MCP workflow) for a natural-language task request. It distinguishes itself from sibling execution tools, which perform specific actions rather than recommending among workflows.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Usage Guidelines3/5
Does the description explain when to use this tool, when not to, or what alternatives exist?
The phrase 'for a natural-language task request' implies when to use the tool, but it does not provide explicit when-not-to-use guidance or name alternative tools such as ms_execute_task_request or ms_task_catalog. The usage context is implied rather than directly stated.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Behavior2/5
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
With no annotations, the description carries the full burden of disclosing behavioral traits. It mentions 'hash-bound' and 'audited' but does not explain side effects, permissions, idempotency, or the meaning of the dry_run and confirmation_token parameters. The tool likely creates or modifies files, but that is not explicitly stated.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Conciseness5/5
Is the description appropriately sized, front-loaded, and free of redundancy?
The description is a single, efficient sentence with no wasted words. It is front-loaded with the primary verb and resource, making it easy to parse and remember.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Completeness2/5
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
Despite having an output schema, the description is insufficient for a tool with eight parameters and no annotations. It fails to explain key concepts like 'hash-bound', 'audited', and how the parameters relate to the overall workflow, leaving the agent without enough context to invoke it 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?
Schema description coverage is 0%, and the description adds minimal meaning beyond the schema. The phrase 'hash-bound' hints at input_sha256, and 'audited' hints at confirmation_token, but these are not mapped to parameters explicitly. Most of the eight parameters, including dry_run, idempotency_key, and timeout_seconds, 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 action ('Export') and the specific resource ('hash-bound project XSD') and output ('audited CAR/MDF pair'). This distinguishes it from sibling tools that perform other conversions or checks, such as md_convert_to_lammps_checked.
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, prerequisites, or conditions. It merely states what the tool does without any contextual or exclusionary information.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Behavior2/5
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
With no annotations, the description carries full burden. It discloses the non-overwriting behavior and reproducibility intent, but it does not explain what happens if the project directory already exists, what the manifest contains, whether permissions are needed, or what the return/output looks like. This is insufficient for a mutation tool with no annotation safety cues.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Conciseness5/5
Is the description appropriately sized, front-loaded, and free of redundancy?
The description is a single, front-loaded sentence with no filler. Every word contributes meaning, and the key action and object are immediately clear. It is appropriately concise for the information it conveys.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Completeness2/5
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
Despite having an output schema, the tool has no annotations and four parameters with zero schema description coverage. The description does not explain invocation context, parameter roles, or behavior on existing projects, making it incomplete for reliable agent selection and 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%, and the description provides no parameter-level explanation. It does not mention project_id, title, dry_run, or projects_root, leaving critical details like dry_run semantics and projects_root usage completely unexplained. The description adds no meaning beyond the raw 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?
Description uses a specific verb ('Create') with a specific resource ('MS/LAMMPS/VMD project directory and manifest') and clearly distinguishes this initialization tool from sibling project-management tools like md_project_get or md_project_update_specification. The qualifiers 'non-overwriting' and 'reproducible' further narrow its purpose.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Usage Guidelines3/5
Does the description explain when to use this tool, when not to, or what alternatives exist?
The phrase 'non-overwriting' and the tool name 'initialize' imply this is for creating a new project rather than updating or inspecting one, but no explicit when-to-use/not-use guidance or alternative tool names are given. The usage context is implied rather than stated.
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 side effects and behavior. It indicates a write-like action ('register') and lists metadata fields, but does not explain whether the operation modifies existing files, overwrites metadata, requires permissions, or behaves differently with dry_run. The dry_run and idempotency_key parameters suggest important behavioral nuances that are not mentioned.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Conciseness5/5
Is the description appropriately sized, front-loaded, and free of redundancy?
The description is a single, concise sentence that front-loads the primary action and resource. No unnecessary words or information, achieving maximum efficiency.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Completeness2/5
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
Despite the presence of an output schema, which covers return values, the description is too sparse for a tool with 6 parameters, 3 required, and no parameter descriptions. It lacks context about the meaning of parameters, side effects, and when to use it within the broader project lifecycle. The complexity of the tool is not matched by the description.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Parameters2/5
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
Schema description coverage is 0%, so the description must compensate. It mentions 'role' and 'provenance' (likely mapping to 'source'), but does not explain artifact_path, project_directory, dry_run, or idempotency_key. The reference to 'size' and 'SHA-256' suggests computed metadata, but the parameters' meanings remain ambiguous. This is insufficient for a 6-parameter tool.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Purpose5/5
Does the description clearly state what the tool does and how it differs from similar tools?
The description uses a specific verb 'register' and clearly states the resource ('a project file') and the type of metadata involved (role, provenance, size, SHA-256 integrity). This clearly distinguishes the tool from sibling tools like md_project_get or md_project_initialize.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Usage Guidelines2/5
Does the description explain when to use this tool, when not to, or what alternatives exist?
The description does not provide any explicit guidance on when to use this tool versus alternatives. It does not mention prerequisites, idempotency considerations (despite an idempotency_key parameter), or cases where another tool would be more appropriate. No exclusions or conditions are stated.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Behavior3/5
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
With no annotations provided, the description carries the full burden. It discloses the notable behavior of not running an engine, which is useful. However, it does not mention whether the audit is read-only, requires specific permissions, or produces side effects, leaving behavioral transparency incomplete.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Conciseness5/5
Is the description appropriately sized, front-loaded, and free of redundancy?
The description is a single concise sentence (12 words) that front-loads the core action 'Audit' and the key constraint 'without running any engine.' No filler or redundancy.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Completeness2/5
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
Despite having an output schema, the tool has 5 parameters, including a confirmation_token and nested objects, with no annotations. The description is too sparse to provide adequate context for such a complex tool; it does not address the confirmation flow, prerequisites, or what 'frozen' means in practice.
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 adds no parameter information. None of the five parameters (e.g., confirmation_token, evidence_manifest, dry_run) are explained, so the description fails to compensate for the lack of schema descriptions.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Purpose5/5
Does the description clearly state what the tool does and how it differs from similar tools?
The description clearly states a specific action ('Audit') on a specific resource ('frozen target-model science contract') and adds a distinguishing mode ('without running any engine'). This sets it apart from sibling audit/readiness tools like md_architecture_compliance_audit or md_model_readiness_assess.
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, nor are any exclusions or prerequisites mentioned. The phrase 'without running any engine' implies a use case but does not explicitly state it.
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 full burden for behavioral disclosure. It explicitly says 'read-only,' which is a key safety trait, but it does not describe what the preflight checks, how failures are reported, or any other side effects beyond the read-only claim.
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 front-loaded 'Read-only preflight,' containing zero filler. Every word contributes meaning.
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, the description omits essential context such as how to invoke the tool, what the input manifest should contain, and what the preflight result signifies. It is too minimal for an agent to use confidently, even for a two-parameter tool.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Parameters1/5
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
Schema description coverage is 0%, and the description does not mention input_manifest or input_manifest_sha256 at all. The agent receives no help understanding what these parameters represent, their format, or their purpose, despite the tool name implying a fixed profile.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Purpose5/5
Does the description clearly state what the tool does and how it differs from similar tools?
The description clearly identifies the tool as a 'preflight' for a very specific resource: 'the exact P3-C alpha-quartz CASTEP profile.' This specific verb+resource combination distinguishes it from sibling tools like ms_castep_preflight_checked, which likely handles broader profiles.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Usage Guidelines2/5
Does the description explain when to use this tool, when not to, or what alternatives exist?
No guidance is given about when to use this tool versus alternatives. The description does not mention any prerequisites, exclusions, or scenarios where the fixed-profile preflight should be preferred over other preflight or gateway-readiness tools.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Behavior2/5
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
With no annotations, the description carries full responsibility for behavioral disclosure. It mentions 'audited' and 'exact counts,' hinting at validation, but does not explain what auditing entails, the need for SHA256 verification, charge constraints, or potential side effects. For a tool with 15 required parameters, this is insufficient.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Conciseness5/5
Is the description appropriately sized, front-loaded, and free of redundancy?
The description is a single, front-loaded sentence with no wasted words. It conveys the core action, the species involved, and the target system type efficiently.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Completeness2/5
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
Despite having an output schema, the tool is complex with 18 parameters, yet the description is only one sentence. It omits critical context such as validation steps, charge neutrality requirements, packing tolerances, and the meaning of 'audited.' For such a parameter-heavy tool, this is not adequately complete.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Parameters2/5
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
Schema description coverage is 0%, and the description only hints at water model (SPC/E) and NaCl counts. It provides no meaning for the other 15+ parameters like project_directory, input_sha256, packmol_tolerance_angstrom, or required_final_formal_charge_e. The description adds minimal value over the raw schema.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Purpose5/5
Does the description clearly state what the tool does and how it differs from similar tools?
The description uses a specific verb ('Pack') and names the exact resource: SPC/E water and NaCl counts into an audited periodic slab cell. It clearly distinguishes this from sibling tools like ms_geology_build_periodic_slab_cell and md_build_clayff_spce_nacl_lammps by emphasizing exact counts and the periodic slab context.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Usage Guidelines2/5
Does the description explain when to use this tool, when not to, or what alternatives exist?
No guidance is given on when to use this tool versus alternatives such as ms_geology_place_counterions or md_build_clayff_spce_nacl_lammps. The description implies use for packing exact SPC/E water and NaCl into a periodic slab, but does not state prerequisites, exclusions, or alternative scenarios.
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 must disclose safety and side effects. It only says 'scan', which implies read-only but doesn't explicitly state non-destructive behavior, permissions, or recursive behavior. It doesn't add context beyond the verb.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Conciseness5/5
Is the description appropriately sized, front-loaded, and free of redundancy?
The description is a single sentence with no filler. It's appropriately sized for a simple scan operation.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Completeness2/5
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
Despite having an output schema, the description doesn't address how the scan behaves (e.g., recursive, file type filtering, behavior of max_results). Given zero annotations and zero parameter descriptions, the tool is under-specified for effective use.
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%, but the description doesn't explain any of the three parameters. The parameter names (patterns, root_dir, max_results) are somewhat self-explanatory, but the tool description adds no meaning, leaving the agent to infer how patterns and max_results interact.
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 ('Scan'), the resource ('a workspace folder'), and the specific target ('for Materials Studio files'). This distinguishes it from sibling tools like ms_moc_get_status or ms_search_local_help, which serve different purposes.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Usage Guidelines2/5
Does the description explain when to use this tool, when not to, or what alternatives exist?
No guidance is provided about when to use this tool versus alternatives. It doesn't mention prerequisites, exclusions, or alternative tools such as ms_find_code_examples or ms_moc_open_document.
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, but it fails to mention key behaviors such as the 'checked' mechanism (likely hash verification), default dry_run behavior, confirmation token requirement, or side effects of running a calculation. The term 'preserve evidence bundle' is vague and does not explain what this entails operationally.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Conciseness4/5
Is the description appropriately sized, front-loaded, and free of redundancy?
The description is a single concise sentence with no redundancy. However, it is so brief that it sacrifices valuable details, though this is more a completeness issue than a conciseness flaw. It is front-loaded with the core 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 (10 parameters, 7 required, no annotations, output schema present), the description is severely incomplete. It does not inform the agent about the 'checked' verification, dry-run flow, confirmation tokens, or how to handle idempotency and output slots. The presence of an output schema does not excuse the missing invocation and behavioral context.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Parameters2/5
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
With 0% schema description coverage, the description must compensate but only hints at 'hash-bound' (input_sha256) and 'profile' (profile_id). It does not explain the purpose of 10 parameters including idempotency_key, project_directory, calculation_parameters, output_slot, dry_run, timeout_seconds, and confirmation_token. This is insufficient for an agent to construct a valid invocation.
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 core action ('Run one hash-bound Forcite profile') and the preservation of evidence bundle, which distinguishes it from sibling tools like the Castep variants. It uses a specific verb and resource, leaving no ambiguity about what the tool does.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Usage Guidelines3/5
Does the description explain when to use this tool, when not to, or what alternatives exist?
The description implies this is the tool for running hash-bound Forcite calculations, but it does not explicitly state when to use this versus alternatives (e.g., other simulation engines). No exclusions or conditional usage 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?
With no annotations, the description carries full responsibility for behavioral disclosure. It only says 'Plan' and 'human-reviewed remedies', but does not state whether the tool has side effects, whether it modifies state, what permissions are required, or how human review is facilitated. For a tool that likely orchestrates human review, this is a significant gap.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Conciseness5/5
Is the description appropriately sized, front-loaded, and free of redundancy?
The description is a single, efficient sentence that front-loads the core purpose. It contains no redundant words and is highly scannable.
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 a required nested object (model_spec) and an optional array, plus a broader sibling tree with related tools like md_model_readiness_assess, the description is too terse. It does not clarify what constitutes a 'local' vs 'human-reviewed' remedy, how the plan is structured, or how it connects to upstream/downstream tools.
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 either parameter (model_spec or search_roots). With two parameters including a nested object, the description offers no guidance on what values to provide or their semantics. This is a complete failure to compensate for the schema's silence.
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 'Plan' with a clear resource ('remedies for model inputs that are not yet ready'), and it distinguishes itself from sibling tools like md_model_readiness_assess by focusing on the planning of remedies rather than assessment. The qualifiers 'local and human-reviewed' add precision about the nature of the remedies.
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 a clear usage context: when model inputs are not yet ready. It implicitly indicates that this tool is for planning remediation rather than executing it. However, it does not explicitly name alternatives or state when not to use it, so it falls short of the highest bar.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Behavior3/5
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
With no annotations, the description carries the burden of disclosing side effects. It states it only checks tools and does not run a simulation, implying a non-destructive read-only operation. However, it doesn't disclose what specific checks are performed, any auth requirements, or the structure of the health report, so transparency is limited.
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, front-loaded with the primary action 'Check', and every word contributes meaningful information. There is no redundancy or wasted text.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Completeness3/5
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
The tool is simple with one optional parameter and an output schema, so the description doesn't need to detail return values. However, it doesn't explain what 'health check' entails, how the optional parameter affects behavior, or what 'conversion and packing tools' specifically refer to. Adequate but with notable 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 schema has one boolean parameter, 'run_version_probes', with zero description coverage. The tool description does not mention this parameter at all, leaving the agent to guess what 'version probes' means and how it affects the health check. This is a clear gap that the description should compensate for.
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 checks a specific set of tools (MS, LAMMPS, MPI, VMD, conversion, packing) and explicitly notes it does not run a simulation. This is a specific verb+resource combination that distinguishes it from simulation-running sibling tools, though it doesn't explicitly name alternatives.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Usage Guidelines3/5
Does the description explain when to use this tool, when not to, or what alternatives exist?
The phrase 'without running a simulation' implies this is a pre-simulation diagnostic, but there is no explicit statement of when to use it versus alternatives like ms_detect_installation or ms_moc_get_status. Usage guidance is only implied, not explicitly stated.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Behavior3/5
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
With no annotations, the description carries the full burden. It does disclose the key safety behavior of requiring explicit network opt-in, which is valuable. However, it does not explain other behavioral aspects such as dry-run semantics, confirmation token flow, or any potential side effects, 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.
Conciseness5/5
Is the description appropriately sized, front-loaded, and free of redundancy?
The description is a single sentence with no redundant words. It front-loads the core action and key condition, making it highly concise while conveying essential 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?
For a tool with 6 parameters and no annotations, the one-sentence description is too sparse. It omits how the confirmation token works, the role of dry_run, and any provider constraints beyond 'fixed-provider'. Although an output schema exists, parameter semantics remain under-specified, making the tool hard to use correctly.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Parameters2/5
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
Schema description coverage is 0%, so the description must compensate. It adds meaning for 'provider' (fixed to PubChem/Crossref) and the network opt-in requirement, but leaves confirmation_token, max_results, and dry_run unexplained. This is insufficient given the complete lack of schema descriptions.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Purpose5/5
Does the description clearly state what the tool does and how it differs from similar tools?
The description clearly states the tool reads PubChem/Crossref metadata, with a specific action ('Read') and resource. The 'fixed-provider' qualifier and explicit network opt-in condition distinguish it from sibling tools like ms_search_local_help, which focus on local resources.
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 explicit guidance on when to use this tool versus alternatives. It implies external metadata retrieval but never names alternative tools or conditions beyond the network opt-in, leaving usage context largely 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 are provided, so the description carries full burden. It mentions 'preflight' and 'new immutable task,' but does not disclose side effects on the original task, authorization requirements, or the confirmation flow, leaving significant behavioral gaps 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?
A single, focused sentence that gets straight to the point. No filler or 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?
Despite having an output schema, the description omits critical workflow context: how preflight relates to dry_run, when confirmation_token is needed, and what the retry actually does to the original task. The tool's complexity is not fully addressed.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Parameters1/5
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
Schema description coverage is 0%, and the description provides no explanation of task_id, owner_capability, dry_run, or confirmation_token. The name 'owner_capability' and 'confirmation_token' are not self-explanatory, so the description fails to compensate for the missing schema details.
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: retry an owned failed or cancelled task as a new immutable task. It uses a specific verb and resource, and the phrase 'failed or cancelled' and 'owned' distinguish it from sibling tools like submit, query, and cancel.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Usage Guidelines4/5
Does the description explain when to use this tool, when not to, or what alternatives exist?
The description implies when to use this tool: for an owned task that failed or was cancelled and needs to be retried. It clearly specifies the precondition without explicitly naming alternatives, which is sufficient given the sibling tool list.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Behavior3/5
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
With no annotations, the description carries the full burden. It discloses useful behavior: outputs are 'hash-bound' and 'execution-blocked', which are non-trivial traits. However, it does not address side effects like file overwriting, permissions, or failure modes, leaving significant unknowns.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Conciseness5/5
Is the description appropriately sized, front-loaded, and free of redundancy?
The description is a single sentence that front-loads the core action and key constraints. It is concise with zero waste, making it easy to parse quickly.
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 7 parameters, a nested object, and no annotations, this description is too sparse. It does not explain what 'hash-bound' or 'execution-blocked' mean in practice, what the expected output schema is, or how to structure the standalone_context. The output schema exists but cannot compensate for the lack of execution guidance.
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 of the 7 parameters (e.g., input_xsd, input_sha256, standalone_context). The agent must rely solely on parameter names, which is insufficient for understanding nested structures like standalone_context.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Purpose5/5
Does the description clearly state what the tool does and how it differs from similar tools?
The description uses the specific verb 'Prepare', names the output resource ('.cell/.param files'), and adds distinguishing attributes ('hash-bound', 'execution-blocked', 'standalone CASTEP'). This clearly differentiates it from sibling tools like ms_prepare_castep_pl_package.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Usage Guidelines3/5
Does the description explain when to use this tool, when not to, or what alternatives exist?
The description implies when to use this tool (for preparing standalone CASTEP inputs), but it provides no explicit alternatives, exclusions, or prerequisites. It does not mention that other tools like ms_prepare_castep_pl_package might be used for pipeline packages instead.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Behavior3/5
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
No annotations are provided, so the description carries the full burden of behavioral disclosure. The verb 'Read' implies a non-destructive operation, but the description does not mention error behaviors, permission requirements, or side effects. For a simple read operation, the read-only nature is somewhat transparent, but more detail could be expected.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Conciseness5/5
Is the description appropriately sized, front-loaded, and free of redundancy?
The description is a single, front-loaded sentence that contains no superfluous information. It is appropriately concise for the tool's simplicity, earning 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?
While the output schema likely documents return values, the description lacks context about the project lifecycle (e.g., whether the project must already be initialized) and the nature of the manifest. Given the tool's simplicity and the presence of an output schema, the description is minimally adequate but leaves gaps in workflow understanding.
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 description does not explain the 'project_directory' parameter or its expected format; it only appears in the schema with a title. With 0% schema description coverage, the description should compensate by clarifying how the directory is used or validated, which it does not. The agent is left to infer that it is a filesystem path.
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 reads a pipeline project's manifest, using a specific verb ('Read') and a distinct resource ('pipeline project's manifest'). This distinguishes it from sibling tools like md_pipeline_get_config (reads config) and project mutation tools. The purpose is unambiguous.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Usage Guidelines2/5
Does the description explain when to use this tool, when not to, or what alternatives exist?
The description provides no guidance on when to use this tool versus alternatives, nor does it mention exclusions or prerequisites. It only states the core action, leaving the agent to infer usage. No sibling alternatives or contextual triggers 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 are provided, so the description carries full burden. The word 'Check' suggests a read-only operation, but it does not explicitly confirm that the tool makes no modifications, nor does it describe the output format, success/failure behavior, or any side effects. Given the absence of annotations, more behavioral disclosure is needed.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Conciseness5/5
Is the description appropriately sized, front-loaded, and free of redundancy?
The description is a single, well-structured sentence that leads with the verb 'Check' and immediately conveys the resource and scope. There is no waste; every word contributes meaning.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Completeness3/5
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
The description gives the core purpose and file scope, and an output schema exists to document return values. However, it lacks context about when to run this preflight in a workflow, prerequisites (e.g., file accessibility), and how the results should be interpreted or acted upon. For a tool with no annotations and no parameter descriptions, this is an adequate but not complete description.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Parameters2/5
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
Schema description coverage is 0%, so the description must compensate for the parameters. It mentions 'charge issues,' which loosely relates to 'charge_tolerance,' but it does not explain the meaning or acceptable range of that parameter, nor does it describe how 'path' should be specified (e.g., relative vs absolute, file types). The description provides only marginal value over the raw 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's function: checking XSD or LAMMPS data files for specific categories of issues (structural, topology, type, cell, charge). It uses a specific verb and resource, and the mention of these file formats and issue types distinguishes it from sibling preflight tools focused on other codes (e.g., CASTEP).
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Usage Guidelines3/5
Does the description explain when to use this tool, when not to, or what alternatives exist?
The description implies when to use this tool—whenever an XSD or LAMMPS data file needs a preflight check—but it does not explicitly contrast it with alternative preflight tools in the sibling list (e.g., ms_castep_fixed_profile_preflight, md_msi2lmp_preflight). No when-not-to-use or alternative guidance is provided.
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 adds a meaningful behavioral trait: 'fail-closed validate' and 'read' imply non-mutating, safety-oriented behavior. However, it does not explain what fail-closed means in practice (e.g., errors on missing data), nor does it disclose side effects, permissions, or output behavior beyond the existence of an output schema.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Conciseness5/5
Is the description appropriately sized, front-loaded, and free of redundancy?
The description is a single, front-loaded sentence that states the action and object with no filler. Every word contributes meaning, 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.
Completeness3/5
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
The output schema exists, so return details are not required. However, the description lacks usage guidance and parameter semantics, which are essential for the agent to correctly invoke the tool. It is adequate for a simple one-parameter reader but incomplete in contextual decision-making.
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 only parameter, contract_path, has no schema description (0% coverage). The tool description adds context that the path points to a mineral nanopore construction contract, but does not clarify the expected format, whether it is a file or directory, or any constraints. The description provides minimal added value over the schema's title.
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 fail-closed validate') and identifies the resource ('mineral nanopore construction contract'), clearly distinguishing this tool from sibling tools that focus on building or packing structures. It fully explains what the tool does.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Usage 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, and does not mention exclusions or prerequisites. Siblings like md_project_validate or md_structure_preflight could overlap, but the description does not differentiate or offer selection advice.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Behavior2/5
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
No annotations are provided, so the description must carry the full burden of behavioral disclosure. It only says 'list', implying a read-only operation, but does not mention side effects, requirements, or error behavior. This is minimal guidance that adds little beyond the tool name.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Conciseness5/5
Is the description appropriately sized, front-loaded, and free of redundancy?
The description is a single, concise sentence that is front-loaded with the action and resource. No unnecessary words or repetition.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Completeness3/5
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
The tool is simple with optional parameters and an output schema, so the description needn't explain return values. However, it leaves ambiguity around how pattern works (glob syntax) and what happens with max_results. It is minimally adequate but lacks some operational details.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Parameters2/5
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
Schema description coverage is 0%, so the description should compensate for the lack of parameter documentation. The description hints at file extensions (.xsd, .xtd) but does not explain the pattern or max_results parameters. The defaults in the schema help, but overall the description adds marginal value.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Purpose5/5
Does the description clearly state what the tool does and how it differs from similar tools?
The description clearly states the action (List), the resource (built-in Materials Studio example documents), and provides examples (.xsd, .xtd). This distinguishes it from sibling tools like ms_list_analysis_targets and ms_scan_workspace, which target different resources.
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 discovering available example documents, but it doesn't explicitly specify when to choose this over alternatives or mention exclusions. The context is clear enough for a simple list operation, but no comparative 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?
No annotations are provided, so the description carries the full burden of disclosing behavior. It only says 'Validate' without explaining whether the tool is read-only, what side effects might occur, what happens on failure, or what the output looks like. The tool name 'preflight' implies a non-destructive check, but that is not explicitly stated.
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, front-loaded with an action verb, and includes the essential scope without any filler. Every word contributes to understanding the tool's 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?
For a tool with 4 parameters and no annotations, the description is minimal. It does not mention prerequisites (e.g., having a CAR/MDF pair from a prior export), what constitutes a successful validation, or how failures are reported. While an output schema exists, the validation logic and conditions are left unspecified, making the description insufficient for complete agent understanding.
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%, but the description maps key parameters to their roles: CAR/MDF pair (car_path, mdf_path), forcefield class (forcefield_class), and explicit parameter file (forcefield_file). It adds meaningful grouping and context, but does not explain formats, defaults, or validation criteria.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Purpose5/5
Does the description clearly state what the tool does and how it differs from similar tools?
The description clearly states the tool's function with a specific verb ('Validate') and specific resources (CAR/MDF pair, forcefield class, explicit parameter file). It also situates the action 'before conversion,' which distinguishes it from sibling conversion tools like md_convert_to_lammps_checked.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Usage Guidelines4/5
Does the description explain when to use this tool, when not to, or what alternatives exist?
The phrase 'before conversion' provides clear temporal context, implying this tool should be used as a preflight step prior to a conversion tool. However, it does not explicitly name alternatives or state when not to use it, such as if the user only needs a structure preflight (md_structure_preflight).
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 a higher burden. It reveals a security-relevant trait (ownership proof required), but does not disclose error behavior, whether the operation is strictly read-only, or what happens if ownership is not proven. The word 'Query' implies non-mutating, but more detail on failure modes would improve transparency.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Conciseness5/5
Is the description appropriately sized, front-loaded, and free of redundancy?
The description is a single sentence of eight words, immediately front-loaded with the verb 'Query'. It contains zero filler and conveys the primary action, the target, and a key constraint. Every word earns its place.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Completeness3/5
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
The tool has only two required parameters and an output schema, which lowers complexity. However, the ownership-proof mechanism is vague—it does not explain where 'owner_capability' comes from or how to obtain it, and there is no mention of error handling or prerequisites beyond the ownership condition. The description is minimally sufficient but not complete for an AI agent to confidently invoke the tool in all situations.
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 vaguely ties 'owner_capability' to proving ownership without explaining its format, origin, or validity. 'task_id' is self-explanatory from its name, but neither parameter receives meaningful semantic elaboration. The description does not compensate for the lack of schema descriptions.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Purpose5/5
Does the description clearly state what the tool does and how it differs from similar tools?
The description uses a specific verb ('Query') and names a specific resource ('one persisted task'), with a clear condition ('after proving ownership'). This distinguishes it from sibling tools like md_task_submit, md_task_cancel, and md_task_retry, which perform different 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?
The description implies when to use the tool (for querying a persisted task) and adds a prerequisite (ownership proof), but it does not explicitly compare with alternatives or state when not to use it. Given the large number of task-related sibling tools, explicit guidance about using this instead of submit/cancel/retry would be beneficial.
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 description implies a read-only status operation but does not explicitly state behavioral traits such as absence of side effects, error conditions, or required environment. With no annotations provided, the description carries the full burden and falls short.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Conciseness5/5
Is the description appropriately sized, front-loaded, and free of redundancy?
The description is one concise sentence that immediately conveys the tool's purpose without extraneous detail. It is front-loaded and earns high marks for structure.
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 status-check tool with no parameters and an output schema, the description is sufficient to convey the core action and object, though it lacks contextual guidance about prerequisites or alternatives. The presence of an output schema reduces the need to explain return values.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Parameters4/5
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
The input schema has zero parameters, so there is nothing to clarify; the description naturally adds no parameter semantics. According to the rubric, a baseline score of 4 is appropriate for a zero-parameter tool.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Purpose5/5
Does the description clearly state what the tool does and how it differs from similar tools?
The description uses a specific verb 'Return' and specifically names the resource 'readiness of the local Materials Studio desktop-control layer,' clearly distinguishing it from sibling tools like 'md_pipeline_health_check' which target a different layer. It is crisp and unambiguous.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Usage Guidelines2/5
Does the description explain when to use this tool, when not to, or what alternatives exist?
The description offers no guidance on when to invoke this tool versus alternatives; it simply states its function. No exclusions, prerequisites, or preferred contexts are mentioned.
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 provided, the description carries the full burden. It transparently discloses that the tool is 'intentionally plan-only' and will not execute anything, which is critical behavioral information that prevents the agent from expecting side effects. It also hints at 'gates' that must be reviewed, adding useful context, even though it stops short of describing the full output or side-effect profile.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Conciseness5/5
Is the description appropriately sized, front-loaded, and free of redundancy?
The description is two concise sentences totaling 33 words. It front-loads the core purpose in the first sentence and adds a practical usage note in the second. Every sentence earns its place without 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?
The tool has 6 parameters and no annotations, making it moderately complex. The description only covers the high-level plan-only behavior and left the agent guessing about parameter meanings, the nature of 'gates,' and what constitutes a high-level workflow. While an output schema exists, the input side is severely under-specified for reliable selection and 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%, so the description must compensate by explaining parameters. It does not mention any of the six parameters (request, keep_job_dir, input_structure, input_trajectory, output_directory, calculation_context) or their meaning. The only reference to parameters is a generic directive to 'review its typed parameters,' which offers no semantic value.
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 function: 'Plan a high-level workflow without executing it.' It uses a specific verb and resource, and explicitly distinguishes itself from execution-oriented tools by noting that natural-language requests are 'intentionally plan-only.' This effectively separates it from siblings like md_task_submit or ms_recommend_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 clear usage context: this tool is for planning, and the agent should then 'Call the selected controlled tool explicitly after reviewing its typed parameters and gates.' This tells the agent when to use it (before execution) and what to do after, though it does not explicitly name alternative tools or exclusion criteria.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Behavior3/5
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
With no annotations provided, the description carries the burden of disclosing behavior. It does state that the tool extracts 'cleaned text and code examples', which gives some insight, but it lacks details on error handling, path validity, or the nature of the cleaning process. The read-only nature is implied but not explicit.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Conciseness5/5
Is the description appropriately sized, front-loaded, and free of redundancy?
The description is a single, concise sentence that front-loads the action and resource. Every word contributes meaning without redundancy, making it highly efficient for an agent 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?
The tool is simple (one parameter) and has an output schema that likely describes return values, so low complexity helps. However, the description never mentions prerequisites (e.g., a local installation or installation detection) or what to do if the path is invalid. Without annotations, these gaps reduce completeness for a standalone operation.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Parameters3/5
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
The input schema has 0% description coverage for the single 'path' parameter, so the description must compensate. It merely refers to 'specific local Materials Studio help page', which clarifies the path is a local file path but adds no format, extension, or resolution details. Minimal value added 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 clearly states the verb 'read' and the specific resource 'local Materials Studio help page', and specifies the action of extracting cleaned text and code examples. It distinguishes itself from sibling tools like ms_search_local_help by focusing on reading a specific page rather than searching for pages.
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 a practitioner already knows the path to a specific help page, but it does not explicitly state when to use this tool over ms_search_local_help or ms_find_code_examples. There is no mention of alternative tools or exclusions, so guidance is only 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?
With no annotations provided, the description carries the full burden of behavioral disclosure. 'Audit' suggests a read-only operation, but the description does not confirm whether there are side effects, permission requirements, or what the audit entails beyond the baseline. No additional behavioral context is given.
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, focused sentence that directly states the purpose and scope. It is appropriately concise and front-loaded with the action verb.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Completeness4/5
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
The tool is simple with no parameters and has an output schema, so the description does not need to explain return values. The description clearly states what is audited and against which baseline, providing sufficient context. Slightly more detail on what constitutes the 'public MCP surface' could improve completeness, but it is adequate.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Parameters4/5
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
The tool has zero parameters, so the baseline for this dimension is 4. The description does not need to add parameter details, and since there are no parameters, there is no missing semantics to compensate for.
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 ('audit') and names a clear resource ('the public MCP surface') with a specific baseline ('reviewed Windows/MS 2023 safety baseline'). This distinguishes it from sibling audit-like tools such as md_scientific_gate_audit or md_model_readiness_assess by focusing on the MCP surface and compliance baseline.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Usage Guidelines3/5
Does the description explain when to use this tool, when not to, or what alternatives exist?
The description implies the tool is used when one needs to verify compliance of the MCP surface against the safety baseline, but it does not explicitly state when to use it over other audit tools, and no alternatives or exclusions are mentioned. This is implied usage rather than explicit 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 discloses that the output is redacted and safe for MCP clients, which is useful behavioral context beyond the simple name. However, it does not specify what is redacted or any error behavior, and there are no annotations to provide additional safety guarantees.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Conciseness5/5
Is the description appropriately sized, front-loaded, and free of redundancy?
The description is a single, front-loaded sentence that is concise and to the point, with no filler.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Completeness4/5
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
Given the tool has no parameters and an output schema is available, the description provides sufficient core information. However, it lacks any usage differentiation from sibling tools, which may reduce its completeness in a large toolset.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Parameters4/5
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
The tool has zero parameters, so the input schema is empty. The description adds no parameter details, but none are needed; the baseline for zero-parameter tools 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?
The description clearly states the tool returns a redacted pipeline configuration summary, using a specific verb and resource. It distinguishes from siblings like md_pipeline_health_check by focusing on configuration summary rather than health status.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Usage Guidelines2/5
Does the description explain when to use this tool, when not to, or what alternatives exist?
No guidance is provided on when to use this tool versus alternatives. The description only states what it does without mentioning exclusions or preferred contexts.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Behavior3/5
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
With no annotations provided, the description must carry the behavioral burden. It states 'inspect' and 'without submitting', which strongly implies read-only, non-destructive behavior. However, it omits details about what it actually checks (e.g., executables, licenses, resources) and does not explicitly state that it makes no changes, leaving some ambiguity.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Conciseness5/5
Is the description appropriately sized, front-loaded, and free of redundancy?
The description is a single, front-loaded sentence that contains no extraneous words. Every element—inspection, local scope, CASTEP blockers, and non-submission—adds necessary value.
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?
This is a simple tool with one optional parameter and an output schema, so the description doesn't need to explain return values. The core purpose and non-submission safety are clear, but the missing parameter semantics and lack of context about the Gateway setup leave the description only partially complete for correct invocation.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Parameters2/5
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
The schema description coverage is 0%, and the description does not mention 'requested_cores' at all. It fails to explain how the parameter influences the readiness check or what the default of 12 means. The agent is left to infer from the parameter name alone, which is insufficient.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Purpose5/5
Does the description clearly state what the tool does and how it differs from similar tools?
The description clearly identifies the action (inspect and report), the resource (local Gateway), the subject (CASTEP submission blockers), and a critical constraint (without submitting). This specificity distinguishes it from sibling tools that check status, health, or submission execution.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Usage Guidelines4/5
Does the description explain when to use this tool, when not to, or what alternatives exist?
The phrase 'without submitting' clearly establishes the tool as a pre-submission readiness check, implying usage before an actual CASTEP job submission. It provides clear context for when to use, but it does not explicitly name alternative tools or exclusion scenarios, so full differentiation from siblings is missing.
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. 'Detect' suggests a read-only operation, but the description doesn't explicitly state whether it modifies anything, requires permissions, or what happens if the installation is missing. It's adequate for a simple detection tool but lacks explicit safety disclosure.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Conciseness5/5
Is the description appropriately sized, front-loaded, and free of redundancy?
The description is a single concise sentence, directly stating the action and target. No fluff or redundancy, and it's front-loaded with the verb 'Detect'.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Completeness4/5
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
For a zero-parameter detection tool with an output schema, the description is reasonably complete. It tells the agent what to expect (detected installation and key paths). However, it doesn't mention whether this is a prerequisite for other tools or any failure modes, which would be useful context. Given the low complexity, a score of 4 is appropriate.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Parameters4/5
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
The tool has zero parameters, and schema coverage is 100%. The description doesn't need to explain any parameters, and the baseline for 0 params is 4. No additional semantics are required.
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 'detect' and clearly names the resource: 'local BIOVIA Materials Studio 2023 installation and key paths.' This clearly distinguishes the tool from siblings like ms_moc_get_status or ms_castep_preflight, which target other aspects. It's explicit and unambiguous.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Usage 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, nor any mention of prerequisites or exclusions. The description implies it's for finding installation paths, but doesn't state if it should be run before other MS tools or what conditions require it. This is a clear gap.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Behavior2/5
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
With no annotations, the description carries the full burden. The verb 'list' implies a read-only operation, but it does not explicitly state that it has no side effects, what output format to expect, or any prerequisites. This lack of behavioral detail is a notable gap.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Conciseness5/5
Is the description appropriately sized, front-loaded, and free of redundancy?
A single sentence, front-loaded with the verb 'List', and no superfluous information. Every word 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 zero-parameter discovery tool with an output schema, the description is complete. It clearly states what the tool returns at a high level without needing to explain return value details. The only slight gap is the lack of explicit usage context, but overall 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 tool has zero parameters, so the baseline is 4. The description adds context by specifying exactly what is listed (high-level workflows and helper tools), which is meaningful even though no parameter details are needed.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Purpose5/5
Does the description clearly state what the tool does and how it differs from similar tools?
The description uses the specific verb 'list' with a clear resource ('high-level workflows and helper tools'), and it is distinct from all sibling tools, none of which serve as a catalog. The purpose is unmistakable.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Usage Guidelines3/5
Does the description explain when to use this tool, when not to, or what alternatives exist?
The intended use is implied (e.g., when you need to discover available workflows and tools), but there is no explicit when-to-use or when-not-to-use guidance, nor mention of alternatives. The context is clear enough for a catalog tool, but no exclusions or alternatives are 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 the full burden of behavioral disclosure. It explicitly reveals two key behavioral traits—'short-lived' (time-limited, aligning with ttl_seconds) and 'single-use' (one-time consumption)—which go beyond the schema. It doesn't mention side effects or prerequisites, but the disclosed traits are valuable.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Conciseness5/5
Is the description appropriately sized, front-loaded, and free of redundancy?
The description is a single, front-loaded sentence with no filler. Every word contributes to meaning: issue, short-lived, single-use, exact, production operation.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Completeness3/5
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
The tool has nested parameters, no annotations, and an output schema. The description explains purpose and key constraints but leaves gaps about what to put in parameters, what makes an operation 'production', and how the confirmation is consumed. Given the complexity, more context would be helpful.
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 hints at parameter meaning by linking 'short-lived' to ttl_seconds and 'exact production operation' to tool_name/parameters, but it doesn't specify the structure of the parameters object or how tool_name is used. Partial compensation only.
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 ('issue') and resource ('confirmation') with clear qualifiers: short-lived, single-use, and for an exact production operation. This clearly states what the tool does and inherently differentiates it from sibling tools, none of which focus on issuing confirmations.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Usage Guidelines3/5
Does the description explain when to use this tool, when not to, or what alternatives exist?
The description implies when to use the tool (when a confirmation for a production operation is needed) but provides no explicit alternatives, exclusions, or context compared to other tools like md_task_submit or ms_execute_task_request. Usage guidance is minimal but not absent.
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:

[![materials-studio-mcp-moc MCP server](https://glama.ai/mcp/servers/christopher2lllp3t-cell/materials-studio-mcp-moc/badges/card.svg)](https://glama.ai/mcp/servers/christopher2lllp3t-cell/materials-studio-mcp-moc)

Score Badge

Copy to your README.md:

[![materials-studio-mcp-moc MCP server](https://glama.ai/mcp/servers/christopher2lllp3t-cell/materials-studio-mcp-moc/badges/score.svg)](https://glama.ai/mcp/servers/christopher2lllp3t-cell/materials-studio-mcp-moc)

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/christopher2lllp3t-cell/materials-studio-mcp-moc'

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