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, but it only says the tool 'Run[s]' calculations. It does not mention whether jobs are submitted, whether files are created or modified, the meaning of the default dryRun=true, or whether a confirmToken is needed. This is a significant gap for a tool that likely executes computational workloads.

Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.

Is the description appropriately sized, front-loaded, and free of redundancy?

The description is a single, front-loaded sentence with no fluff, and the core action is stated immediately. However, it is so brief that it misses important behavioral context, so it is concise but not optimally informative for the tool's complexity.

Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.

Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?

For a tool with 7 parameters, no output schema, and no annotations, this description is incomplete. It lacks essential details about dryRun behavior, project file handling, settings structure, confirmToken requirements, and what the tool returns or changes, making it insufficient for an agent to invoke it correctly in varied situations.

Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.

Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?

Schema description coverage is very low (14%), so the description must compensate, but it only adds meaning for inputDocument ('located under the MS-MCP work root') and partially for task by listing preset names. It provides no explanation for cores, dryRun, project, settings, or confirmToken, leaving most parameters underspecified.

Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.

Does the description clearly state what the tool does and how it differs from similar tools?

The description clearly states the verb 'Run' and the resource 'CASTEP task or preset calculation on an input document', which is specific and actionable. It names the main presets, helping an agent understand the tool's scope, though it does not explicitly contrast with sibling tools like ms_gui_castep_current or ms_remote_castep_batch.

Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.

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 versus alternatives such as GUI-based CASTEP tools or remote job preparation tools. It only implies usage by describing what the tool does, leaving the agent to infer context without any when-not-to-use or alternative routing.

Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.

Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?

Description implies a read-only, side-effect-free operation but does not confirm safety or disclose any behavioral traits; no annotations to compensate.

Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.

Is the description appropriately sized, front-loaded, and free of redundancy?

Single sentence with no wasted words, front-loaded purpose.

Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.

Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?

Sufficient for a simple tool with no parameters or output schema, but could hint at snippet format or usage context.

Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.

Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?

No parameters exist, so description adds no param info; baseline for 0 params is 4.

Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.

Does the description clearly state what the tool does and how it differs from similar tools?

Description clearly states the tool returns an MCP server config snippet for Codex settings, distinct from sibling tools that focus on MS operations.

Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.

Does the description explain when to use this tool, when not to, or what alternatives exist?

No guidance on when or why to use this tool over alternatives; no context provided for integration with Codex settings.

Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.

Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?

No annotations provided; description mentions 'using MaterialsScript' but does not disclose behavioral traits like side effects, permissions, or whether it modifies existing documents. Minimal behavioral context beyond the basic action.

Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.

Is the description appropriately sized, front-loaded, and free of redundancy?

Two efficient sentences: first states purpose, second provides usage guidance. No fluff or redundancy.

Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.

Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?

Given no output schema, no annotations, and 4 parameters, the description is too brief. It explains the tool's purpose and when to use alternatives, but lacks detail on return values, parameter behavior, and potential constraints.

Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.

Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?

Schema has 0% parameter description coverage; the description does not explain individual parameters. It implicitly mentions atoms and bonds but provides no details on formatting, constraints, or how they are used.

Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.

Does the description clearly state what the tool does and how it differs from similar tools?

Clearly states the tool creates a standalone molecule/crystal document from explicit atoms and bonds using MaterialsScript. Distinguishes from sibling tool ms_gui_create_current by specifying it creates a standalone document, not in the GUI.

Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.

Does the description explain when to use this tool, when not to, or what alternatives exist?

Explicitly advises to prefer ms_gui_create_current when working within an open GUI project to avoid duplicate documents, providing clear guidance on when to use this tool vs. alternatives.

Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.

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 description only says 'Run a Forcite task' without explaining whether this submits a job, modifies files, requires confirmation (despite a confirmToken parameter), or how dryRun affects execution. This is a significant omission for a computational tool.

Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.

Is the description appropriately sized, front-loaded, and free of redundancy?

The description is a single sentence, which is concise, but it is so sparse that it provides almost no actionable information. While conciseness is valued, this is under-specification rather than effective brevity; the sentence does not earn its place by adding meaningful detail.

Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.

Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?

Given 7 parameters, nested objects, no output schema, and no annotations, the description is radically incomplete. It omits the purpose of each parameter, default behaviors, return values, and any side effects. An agent would not be able to invoke this tool correctly without external knowledge.

Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.

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 any parameters. It only mentions the input document, but does not clarify the meaning of 'task', 'cores', 'dryRun', 'project', 'settings', or 'confirmToken'. The description fails to compensate for the schema's lack of documentation.

Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.

Does the description clearly state what the tool does and how it differs from similar tools?

The description states a clear verb and resource: 'Run a Forcite task' on an input document, and specifies the location constraint 'under the MS-MCP work root.' It distinguishes this from GUI-based Forcite siblings (e.g., ms_gui_forcite_optimize_current) by implying a compute operation, though it does not explicitly name alternatives. Slight deduction for not naming sibling tools, but the purpose is clear.

Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.

Does the description explain when to use this tool, when not to, or what alternatives exist?

There is no guidance on when to use this tool versus alternatives. It does not mention conditions, prerequisites, or when to prefer this over other computation tools like ms_castep or the GUI Forcite helpers. An agent would have 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.

Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?

The description explains that the tool modifies the document in place and describes the behavior of the two modes. With no annotations provided, it adds some transparency but does not cover side effects, permissions, or prerequisites.

Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.

Is the description appropriately sized, front-loaded, and free of redundancy?

The description is two sentences with no redundant information. It front-loads the core purpose and follows with mode explanations, making it efficient and well-structured.

Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.

Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?

Given 9 parameters and no output schema, the description is insufficient. It covers the main action and two modes but omits parameter details, return behavior, and prerequisites, leaving the agent underinformed.

Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.

Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?

Schema coverage is only 11% (only thickness has a description). The description adds context for 'mode' and implies 'axis' by mentioning 'chosen lattice length', but does not explain other parameters like exportFile, ballAndStick, documentName, etc.

Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.

Does the description clearly state what the tool does and how it differs from similar tools?

The description clearly states the tool adds vacuum to the current GUI periodic document 'in place' and only when explicitly requested. However, it does not differentiate from the sibling 'ms_gui_cleave_surface_vacuum_current', which also deals with vacuum.

Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.

Does the description explain when to use this tool, when not to, or what alternatives exist?

The description explicitly states the tool is used when the user asks for vacuum and explains when to use each mode (extend_lattice for 3D cells, vacuum_slab for 2D surfaces). However, it lacks guidance on when not to use this tool versus alternatives.

Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.

Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?

No annotations are provided, so the description bears full responsibility for behavioral disclosure. The description mentions 'queues' (implying asynchronous operation) and 'modifies in place', but does not elaborate on destructive potential, authentication requirements, rate limits, or what happens to the document state. This is insufficient for a tool that modifies the GUI.

Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.

Is the description appropriately sized, front-loaded, and free of redundancy?

The description consists of two sentences and is front-loaded with the core purpose. It is concise with no redundant information. However, the brevity sacrifices completeness for a tool with six parameters.

Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.

Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?

Given the tool's complexity (6 parameters, no output schema, no annotations), the description is far from complete. It does not explain return values, side effects, or parameter usage. The agent cannot fully understand how to invoke the tool correctly without additional context.

Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.

Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?

Schema description coverage is only 17%, meaning the description adds no value for most parameters. The tool description does not explain any parameter beyond what the schema already provides for 'body'. With 6 parameters (1 required) and no parameter descriptions in the description itself, the agent lacks essential semantic guidance.

Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.

Does the description clearly state what the tool does and how it differs from similar tools?

The description clearly states the verb 'queue' and the resource 'MaterialsScript body that modifies the current GUI document'. It provides an example use case ('on this molecule...' edits), making the purpose clear. However, it does not explicitly differentiate from sibling tools like ms_gui_create_current or ms_gui_edit_current.

Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.

Does the description explain when to use this tool, when not to, or what alternatives exist?

The description includes guidance to 'Use this for 'on this molecule...' edits', implying a context for use. However, it does not specify when not to use this tool, nor does it mention alternatives among the many sibling GUI tools. The usage context is implied but not exhaustive.

Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.

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, but it only says the tool 'queues' a calculation. It does not mention the dryRun default, the need for a confirmToken, whether submission is local or remote, what side effects occur, or what the agent should expect after invocation.

Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.

Is the description appropriately sized, front-loaded, and free of redundancy?

The description is two short sentences with no filler. The main action is front-loaded, and the preset list is a compact, useful expansion of the calculationType semantics.

Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.

Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?

For a tool with 11 parameters, no annotations, and no output schema, this description is too thin. It gives a high-level purpose but omits crucial invocation context such as dry-run behavior, authorization token requirements, output document naming, and how extra settings are passed.

Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.

Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?

Schema description coverage is only 9%, so the description must compensate, but it only adds meaning for calculationType by listing preset names such as 'DOS' and 'band structure'. It does not explain important parameters like dryRun, confirmToken, exportFile, extraSettings, resultDocument, or kPointQuality, leaving most of the 11 parameters underdocumented.

Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.

Does the description clearly state what the tool does and how it differs from similar tools?

The description clearly states the verb 'Queue', the resource 'current GUI document', and the engine 'CASTEP', which is enough to identify the tool's core purpose. It also lists supported calculation presets, but it does not explicitly name or contrast sibling tools, so it stops short of full differentiation.

Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.

Does the description explain when to use this tool, when not to, or what alternatives exist?

The phrase 'on the current GUI document' implies the intended context: run a CASTEP calculation on the active document. However, there is no explicit guidance about when to choose this tool over siblings like ms_castep, ms_gui_prepare_remote_castep_batch, or the other engine-specific current-document tools.

Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.

Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?

No annotations are provided, so the description carries full burden. It mentions using SurfaceBuilder + CrystalBuilder but fails to disclose whether the operation modifies the current crystal, creates a new document, or requires specific permissions. The agent is left unaware of side effects.

Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.

Is the description appropriately sized, front-loaded, and free of redundancy?

The description is two sentences with no redundant information. The key action is front-loaded, and the usage condition is stated directly. Every sentence adds value.

Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.

Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?

With 14 parameters, no output schema, and no explanation of common parameters, the description is insufficient. It does not cover what the tool returns or how parameters like h,k,l affect the result. The tool's complexity demands more context.

Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.

Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?

Schema description coverage is only 14% (2 out of 14 parameters have descriptions). The description adds no parameter information, failing to compensate for the low coverage. Most parameters like h,k,l, capType, cleaveRule, etc., remain unexplained.

Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.

Does the description clearly state what the tool does and how it differs from similar tools?

The description clearly states the tool's action: 'Cleave a surface from the current GUI crystal and build a vacuum slab' using specific builders. It also distinguishes usage from siblings by specifying when to use it, referencing the manual surface workflow.

Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.

Does the description explain when to use this tool, when not to, or what alternatives exist?

The description provides explicit guidance: 'Use only when the user explicitly asks...' This sets a clear condition. However, it does not mention alternatives or when not to use, limiting differentiation from sibling tools like ms_gui_add_vacuum_current.

Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.

Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?

With no annotations, the description should disclose behavioral traits. It says 'create or replace' implying mutation of the current document, but doesn't elaborate on side effects (e.g., overwriting existing content), permissions, or undo capabilities. It mentions the vacuum constraint, but lacks depth on other behaviors like forceNew or coordination type handling.

Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.

Is the description appropriately sized, front-loaded, and free of redundancy?

The description is three sentences, each serving a distinct purpose: defining the action, providing usage priority, and setting a boundary. There is no redundancy or filler. It is front-loaded with the core purpose.

Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.

Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?

Given the complexity (17 parameters, no output schema, no annotations), the description is insufficient for complete agent understanding. It omits guidance on critical parameters like coordinate types, bond calculation, space group, and output handling. A more comprehensive description would cover these or reference documentation.

Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.

Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?

Schema description coverage is low (29%), so the description should add meaning for undocumented parameters. However, it only provides general context about vacuum and CIF alternatives, not explaining key params like a, b, c, atoms, coordinateType, spaceGroup, etc. This leaves agents guessing about parameter usage beyond what the schema provides.

Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.

Does the description clearly state what the tool does and how it differs from similar tools?

The description clearly states 'Create or replace the current GUI document as a periodic crystal/unit cell from lattice parameters and atom coordinates.' It specifies the resource (GUI document) and action (create/replace), and distinguishes from siblings like ms_gui_find_cif_import_current by directing users to that tool first.

Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.

Does the description explain when to use this tool, when not to, or what alternatives exist?

The description explicitly advises to first try ms_gui_find_cif_import_current for new crystals, and to only use manual construction when no CIF is found or user provides credentials. It also warns against adding vacuum unless explicitly requested. This provides clear when-to-use and when-not-to-use guidance.

Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.

Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?

With no annotations, the description carries full burden. It discloses that by default the tool reuses existing documents to avoid duplicates, and that it can replace the current document. However, it does not explicitly mention side effects like overwriting without confirmation or error handling.

Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.

Is the description appropriately sized, front-loaded, and free of redundancy?

The description is three concise sentences: purpose, usage guidance, then default behavior. No redundant information, and critical guidance is front-loaded.

Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.

Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?

Given the tool has 5 parameters, no output schema, and no annotations, the description leaves gaps: it does not describe return values, validate the body input beyond mentioning it, or explain exportFile and ballAndStick behavior. More detail on outcomes and error cases would improve completeness.

Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.

Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?

Schema description coverage is only 40%, but the description adds significant value: it explains that the body parameter should be a MaterialsScript with a pre-created $doc variable, and implies the forceNew parameter's effect by describing default reuse. However, exportFile and ballAndStick parameters are not elaborated.

Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.

Does the description clearly state what the tool does and how it differs from similar tools?

The description clearly states the tool's verb ('Create or replace'), resource ('current GUI document'), and input ('MaterialsScript body'). It distinguishes from sibling tools like ms_gui_find_cif_import_current by recommending that for new structures.

Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.

Does the description explain when to use this tool, when not to, or what alternatives exist?

Explicit guidance is provided: before using for a new structure, try ms_gui_find_cif_import_current first; use this tool only when no reliable open CIF or user credentials are available. This helps the agent decide when to invoke this tool versus alternatives.

Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.

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 side effects. It states that the tool queues a calculation and organizes outputs, but it does not mention that dryRun defaults to true, that a confirmToken may be required, that a GUI session/document must be current, or that job execution is asynchronous. These are significant behavioral gaps for a queueing action.

Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.

Is the description appropriately sized, front-loaded, and free of redundancy?

The description is a single sentence with no filler, and the core action is front-loaded. However, it is so terse that it sacrifices useful behavioral and parameter context, so it earns a high but not top score for structure.

Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.

Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?

For an 11-parameter tool with no annotations and no output schema, this description is materially incomplete. It omits prerequisites, dry-run/confirmation behavior, output details, and any guidance on parameter selection. An agent would need to inspect the raw schema and make risky assumptions to invoke it correctly.

Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.

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 references 'dedicated calculation name/folder,' which maps to calculationName/resultDocument. The other nine parameters receive no explanatory support from the description. With such low coverage, the description fails to compensate.

Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.

Does the description clearly state what the tool does and how it differs from similar tools?

The description names a specific verb ('Queue'), a specific resource ('DMol3 GeometryOptimization'), and a target ('current GUI document'). It also distinguishes this from siblings like ms_gui_forcite_optimize_current and ms_gui_castep_current by naming the DMol3 method explicitly.

Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.

Does the description explain when to use this tool, when not to, or what alternatives exist?

The description implies use for DMol3 geometry optimization on the current document, but it does not explicitly state when to prefer this over the Forcite or CASTEP siblings, nor any exclusions. There is no when-not guidance, so the agent must infer usage from the method name alone.

Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.

Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?

With no annotations, the description carries the behavioral burden, and it delivers: it discloses a network download, one-time session storage, optional GUI import, making the document current, and an important authentication/credential caveat. It does not describe overwrite/replacement consequences or behavior when no GUI session/project is active, but the key state-changing behaviors are visible.

Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.

Is the description appropriately sized, front-loaded, and free of redundancy?

Three compact sentences with no filler. The main action chain is front-loaded, the usage guidance is separated, and the caveat about credentialed databases is distinct and necessary. Every sentence earns its place.

Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.

Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?

For a 7-parameter tool with no output schema and no annotations, the description covers the core call semantics, the modeling workflow context, and the credential limitation. It omits explicit preconditions like requiring an already-started GUI session/project and does not describe return/status values, but the schema handles parameter details and the sibling list provides surrounding context. This is strong, if not exhaustive.

Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.

Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?

Schema description coverage is 86%, so the input schema already documents most parameter meanings. The description mainly reinforces the COD vs. direct URL distinction and optional import behavior, adding little that is not already in the schema. Baseline 3 is appropriate.

Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.

Does the description clearly state what the tool does and how it differs from similar tools?

The description states an explicit action chain: download a CIF from a source or URL, store it once in the session, optionally import into the GUI project, and make it current. This clearly distinguishes it from siblings like ms_gui_find_cif_import_current and ms_gui_import_current, which do not describe downloading from an external source. The verb and resource are specific and actionable.

Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.

Does the description explain when to use this tool, when not to, or what alternatives exist?

It provides a clear when-to-use condition: before modeling when a reliable database CIF is available. It also gives a when-not-to-use boundary around login/license walls and credentialed databases. However, it does not explicitly name alternatives such as ms_gui_import_current for already-downloaded CIF files, so it stops short of full alternative routing.

Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.

Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?

No annotations are present, so the description carries the full burden. It mentions 'queue' but does not disclose asynchronous behavior, how to check completion, undo capabilities, or any side effects. The list of operations provides some insight but misses behavioral details.

Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.

Is the description appropriately sized, front-loaded, and free of redundancy?

The description is a single sentence that is concise and front-loads the purpose. However, it could be slightly more structured by breaking into bullet points or sentences for clarity. No redundant information.

Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.

Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?

Given the tool's complexity (17 parameters, no output schema, no annotations), the description is insufficient. It does not explain return values, the queueing mechanism, prerequisites, or the broader context of molecular modeling. The description leaves significant gaps.

Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.

Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?

Schema description coverage is only 24% (4 out of 17 parameters have descriptions). The tool description adds context for the 'operation' parameter by listing examples but does not explain critical parameters like x, y, z, name, exportFile, or documentName. The parameter meanings remain unclear.

Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.

Does the description clearly state what the tool does and how it differs from similar tools?

The description clearly states the verb 'Queue' and the resource 'current GUI document', and lists specific operations like adding/deleting bonds, changing element, etc. This distinguishes it from sibling tools like crystal creation or lattice settings.

Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.

Does the description explain when to use this tool, when not to, or what alternatives exist?

The description implies usage for basic molecule-building edits on the current document but does not explicitly state when to use this tool versus alternatives like ms_gui_create_crystal_current or ms_gui_set_lattice_current. No 'when-not-to-use' guidance is provided.

Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.

Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?

With no annotations provided, the description carries the full burden, and it discloses meaningful behavior: it only uses open sources, downloads only once, imports into the current project, sets it current, and avoids credential bypassing. It does not fully detail error behavior or all side effects of importing, but it covers the key operational constraints.

Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.

Is the description appropriately sized, front-loaded, and free of redundancy?

The description is three sentences long, front-loads the core workflow, and every sentence contributes either an action, usage context, or an important constraint. There is no redundant or filler content.

Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.

Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?

The description is strong for the main workflow and the open-source/credentialed-database constraint, but with 8 parameters, no output schema, and no annotations, it leaves gaps around parameter semantics, return behavior, and how to route between sibling tools. It is adequate but not fully complete for an autonomous agent.

Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.

Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?

Schema description coverage is only 50%, and the tool description adds no parameter-level meaning beyond the schema. It does not explain how query, formula, fileName, maxResults, importToGui, ballAndStick, documentName, or minConfidence should be used. The description therefore fails to compensate for the missing parameter documentation.

Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.

Does the description clearly state what the tool does and how it differs from similar tools?

The description clearly specifies a multi-step workflow: search open crystallographic databases, download a reliable CIF, import it into the current GUI project, and make it current. This distinguishes it from related siblings like ms_gui_import_current or ms_gui_download_cif_import_current by combining search with import and by narrowing to open sources.

Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.

Does the description explain when to use this tool, when not to, or what alternatives exist?

The description gives explicit when-to-use guidance: 'Use this before manually building a new crystal or molecular crystal.' It also explains what to do when credentialed databases are required, telling the agent to return candidates/reason rather than bypass access. It does not name sibling alternatives explicitly, so it stops short of a 5.

Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.

Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?

With no annotations, the description must carry the full burden. It says 'Queue' which implies asynchronous submission and mentions the folder layout, but it does not disclose side effects, prerequisites, confirmation flow, or result handling. An agent gets no warning about how the job executes or what happens to the current document.

Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.

Is the description appropriately sized, front-loaded, and free of redundancy?

The description is one concise sentence with a front-loaded verb and resource. It is not bloated, but given the tool's complexity, the brevity is more under-specification than skillful conciseness.

Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.

Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?

This is a complex 13-parameter tool with no output schema, no annotations, and 0% schema description coverage. The description omits prerequisites, parameter semantics, asynchronous behavior, and return behavior. It is not complete enough for an agent to use confidently without significant additional inference.

Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.

Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?

Schema description coverage is 0%, and the description does not explain any of the 13 parameters. Details like dryRun, confirmToken, optimizeCell, chargeAssignment, and extraSettings remain entirely undocumented. The description adds essentially no meaning beyond the raw schema.

Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.

Does the description clearly state what the tool does and how it differs from similar tools?

The description clearly states a specific action ('Queue'), resource ('Forcite GeometryOptimization'), and target ('current GUI document'), plus a distinctive folder-layout detail. It is distinguishable from sibling tools like ms_gui_dmol3_optimize_current, though it does not explicitly name them.

Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.

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 Forcite geometry optimization should be run on the current GUI document, with a manual-like folder layout. It does not explicitly state exclusions or alternatives, leaving some ambiguity versus ms_forcite or ms_gui_castep_current.

Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.

Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?

No annotations are provided, so the description carries the burden. It discloses that the tool queues an import and changes the current document, which implies a state-changing operation. It also warns against XSD re-imports, which is useful behavioral context. However, it doesn't disclose what 'queue' means (e.g., asynchronous behavior, whether the import can fail silently, or how to check status via ms_status).

Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.

Is the description appropriately sized, front-loaded, and free of redundancy?

Two sentences, front-loaded with the main action and outcome, followed by a useful exclusion. It is concise and every sentence earns its place, though the second sentence could arguably be folded into usage guidance without losing clarity.

Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.

Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?

For a tool with 4 parameters, no output schema, and no annotations, the description covers the core purpose and a key pitfall, but leaves significant gaps: parameter meanings, asynchronous queue behavior, and how to confirm success. It is adequate for a simple import action but not fully complete for an agent that needs to invoke it correctly with optional parameters.

Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.

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 four parameters. It only explains the purpose of the 'file' parameter implicitly ('Import external source files') and gives no meaning for exportFile, ballAndStick, or documentName. The description adds almost no parameter-level semantics beyond what the bare schema already shows.

Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.

Does the description clearly state what the tool does and how it differs from similar tools?

The description states a specific verb ('Queue an import'), a resource ('the open Materials Studio GUI project'), and a clear outcome ('make the imported document the current document'). It also distinguishes itself from XSD re-imports, which helps differentiate it from sibling tools like ms_gui_download_cif_import_current and ms_gui_find_cif_import_current, though it doesn't explicitly name those siblings.

Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.

Does the description explain when to use this tool, when not to, or what alternatives exist?

The description gives clear context: use it to import external source files into the open GUI project. It also provides an explicit exclusion: do not import XSD files that MS-MCP just exported from the current GUI document. It doesn't name alternative tools for those cases, but the when/when-not guidance is present.

Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.

Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?

No annotations provided, so description carries full burden. It mentions 'in place' implying modification but doesn't disclose whether the original is preserved, whether it's destructive, or any permissions needed. It references 'Materials Studio BuildSuperCell' but doesn't clarify side effects. Parameter calculateBonds has a good warning, but overall behavioral context is lacking.

Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.

Is the description appropriately sized, front-loaded, and free of redundancy?

Single sentence that directly states the purpose without unnecessary words. Efficient and front-loaded.

Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.

Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?

With 8 parameters, no output schema, and no annotations, the one-sentence description is insufficient. It omits context about return values, error conditions, overwriting behavior, or confirmation steps. More detail is needed for a tool that modifies the current document.

Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.

Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?

Schema description coverage is 63% (5 of 8 parameters described). The tool description does not add any meaning beyond the schema; it only names the underlying method. For a moderate coverage, the description should have compensated but didn't.

Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.

Does the description clearly state what the tool does and how it differs from similar tools?

The description clearly states the action ('Build a supercell') and the resource ('current GUI periodic document'), with specific verb and resource. It distinguishes from siblings like ms_gui_create_current or ms_gui_set_lattice_current by focusing on supercell construction. Minor vagueness in 'in place' prevents a 5.

Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.

Does the description explain when to use this tool, when not to, or what alternatives exist?

No guidance on when to use this tool versus alternatives (e.g., ms_gui_create_current for new structures, ms_gui_set_lattice_current for lattice changes). No exclusions or prerequisites mentioned.

Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.

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. 'Queue' suggests asynchronous submission, and 'without creating a new document' is a useful side-effect note, but the description does not disclose whether the operation mutates the document, whether a document must already be open, what documentName does, or what the result of queuing is. This is a significant transparency gap for a tool that performs an operation.

Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.

Is the description appropriately sized, front-loaded, and free of redundancy?

The description is a single, front-loaded sentence with no wasted words. It states the action, the target scope, example operations, and a key exclusion—'without creating a new document'—all in one compact sentence.

Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.

Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?

Despite having five parameters, no annotations, and no output schema, the description omits most of the behavioral and parameter detail an agent needs to invoke this tool correctly. It identifies the operation family and document scope, but not the meaning or expected values of several parameters, nor the side effects of queuing the operation.

Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.

Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?

Schema description coverage is 0%, so the description must compensate for all five parameters. It only hints at the 'operation' parameter by naming Clean and AdjustHydrogen, and it partially clarifies documentName through 'current GUI document.' It does not explain exportFile, ballAndStick, or cleanIterations at all, leaving most parameters semantically opaque.

Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.

Does the description clearly state what the tool does and how it differs from similar tools?

The description states a clear verb and resource: 'Queue a basic Materials Studio modeling-toolbar operation on the current GUI document.' It names concrete examples (Clean, AdjustHydrogen) and explicitly notes it does not create a new document, which helps differentiate it from document-creation siblings. It is slightly vague about what counts as a 'basic' operation, but the examples anchor it well.

Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.

Does the description explain when to use this tool, when not to, or what alternatives exist?

The description gives clear context: use this for basic modeling-toolbar operations on the current GUI document, and it explicitly excludes creating a new document. It does not name sibling tools or state when to prefer them, but the 'current document' and 'without creating a new document' constraints provide useful selection guidance.

Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.

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, and it performs well. It reveals the non-obvious decision logic: never bypass authentication for ICSD/CSD/Materials Project/OQMD, ask the user instead; build the primitive/base document first; and do not name the initial document after a planned supercell size. These are genuine behavioral traits beyond what any schema could convey. It could add more detail on failure modes, but the disclosed traits are substantial.

Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.

Is the description appropriately sized, front-loaded, and free of redundancy?

The content is dense and meaningful, but it is presented as one long run-on block separated by semicolons rather than scannable sentences. The core routing logic is front-loaded ('Unified entry point') which helps, but the wall-of-text format reduces readability for an agent parsing the definition. It is not overly long relative to the complexity of the tool, so it earns a middle score.

Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.

Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?

The description thoroughly covers the decision workflow and naming conventions, which is valuable context. However, for a tool with 26 parameters, no output schema, and no annotations, the complete absence of parameter semantics is a notable gap. An agent can understand the routing strategy but cannot reliably determine how to populate arguments like sourcePolicy, manualMode, minConfidence, or coordinateType to steer that routing. The workflow coverage is strong, but parameter coverage is a real hole.

Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.

Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?

Schema description coverage is only 35%, leaving roughly 17 of 26 parameters undocumented in the schema. The description does not compensate: it contains zero parameter-level guidance. It never explains how query, manualMode, atoms, sourcePolicy, minConfidence, or the cell parameters (a, b, c, alpha, beta, gamma) interact with the described decision workflow. For a high-parameter tool with low schema coverage, the description should have bridged this gap but does not.

Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.

Does the description clearly state what the tool does and how it differs from similar tools?

The description clearly identifies this as the 'Unified entry point for creating a new GUI structure' and states its exact scope: routing first-time structure creation. It explicitly distinguishes itself from siblings by saying 'Prefer this tool over direct create/import tools for first-time structure creation,' which separates it from ms_gui_create_current, ms_gui_import_current, and ms_gui_download_cif_import_current in the sibling list. The verb-resource pairing is specific and unambiguous.

Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.

Does the description explain when to use this tool, when not to, or what alternatives exist?

The description explicitly states when to use it ('for first-time structure creation') and names the alternative category it supersedes ('direct create/import tools'). It also details the internal decision order (CIF-first, then auth-required sources, then manual fallback), which gives an agent a clear sense of the expected workflow. It stops short of enumerating the exact sibling tools it should NOT be used for (e.g., ms_create_molecule for pure molecules), so it is not fully exhaustive.

Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.

Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?

With no annotations, the description carries the burden. It explains the default native_castep mode and the staging process, but omits details about the submissionMode other modes, the effect of stopGuiLoopAfterPrepare, and potential side effects or prerequisites.

Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.

Is the description appropriately sized, front-loaded, and free of redundancy?

The description is two sentences and front-loaded with the core purpose. The second sentence adds relevant detail about the default mode but could be slightly tighter; still efficient overall.

Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.

Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?

Given the tool's complexity (5 params, nested objects, no output schema), the description fails to cover parameters and return behavior. Important context like what happens after preparation or the output format is missing, making it incomplete for reliable invocation.

Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.

Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?

Schema description coverage is 0%; the description does not explain any of the five parameters (tasks, batchName, commonSettings, submissionMode, stopGuiLoopAfterPrepare), leaving the agent without semantic guidance beyond the schema.

Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.

Does the description clearly state what the tool does and how it differs from similar tools?

The description clearly states the tool prepares native CASTEP geometry-optimization jobs or script drivers, specifying two modes and how the default mode stages documents per task. It distinguishes itself from sibling tools like ms_castep and ms_gui_castep_current by focusing on batch preparation.

Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.

Does the description explain when to use this tool, when not to, or what alternatives exist?

No explicit guidance on when to use this tool versus alternatives (e.g., ms_castep, ms_remote_castep_record_submission). The description mentions two modes but does not explain when to choose one over the other or provide context for decision-making.

Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.

Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?

The term 'Ensure' is ambiguous—it may imply creating the directory if it doesn't exist, which is a behavioral trait. Without annotations, the description does not clarify whether side effects (e.g., creation) occur, nor does it mention permissions, idempotency, or error conditions. This lack of transparency could lead to misuse.

Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.

Is the description appropriately sized, front-loaded, and free of redundancy?

The description is a single sentence of 14 words, front-loading the key action ('ensure and return'). It is efficient, though the word 'ensure' could be clarified for better scannability.

Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.

Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?

Given the absence of annotations and output schema, the description carries the full burden of explaining the tool's behavior. It omits details about the return value format, whether the directory is created, and any required permissions. For a simple tool, this may be marginally adequate, but it lacks completeness for an AI agent to understand all nuances.

Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.

Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?

The input schema has zero parameters, so schema description coverage is 100%. According to guidelines, a baseline of 4 is appropriate. The description does not need to add parameter information, and it provides no misleading details.

Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.

Does the description clearly state what the tool does and how it differs from similar tools?

The description clearly identifies the tool's purpose: to ensure and return the current MS-MCP session output directory. The verb 'ensure and return' combined with the resource 'directory' provides specific action and object, distinguishing it from sibling tools like ms_gui_state or ms_list_workspace which have different scopes.

Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.

Does the description explain when to use this tool, when not to, or what alternatives exist?

The description implies usage when the current session output directory is needed, but does not explicitly state when to use this tool versus alternatives like ms_list_workspace. No exclusions or prerequisites are provided, leaving the agent to infer context.

Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.

Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?

With no annotations, the description carries full burden. It discloses that it does not create a file, but omits side effects like changing the current document state, error conditions (e.g., nonexistent document), prerequisites (e.g., active GUI session), and whether previous state is overwritten. This is insufficient for a stateful operation.

Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.

Is the description appropriately sized, front-loaded, and free of redundancy?

The description is two sentences with no fluff. The main purpose is front-loaded, and the clarification about not creating a file is useful. It is concise and well-structured, though it could benefit from a little more detail without becoming verbose.

Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.

Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?

For a tool that changes state and has two parameters with no output schema, the description is incomplete. It lacks information about return values, error handling, parameter semantics, and behavioral edge cases. An agent would be uncertain how to invoke it correctly, especially regarding the optional exportFile parameter.

Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.

Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?

Schema description coverage is 0%, so the description must explain parameters. It does not mention documentName or exportFile at all. The agent cannot infer what exportFile is for or how documentName should be formatted, leaving both parameters effectively undocumented.

Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.

Does the description clearly state what the tool does and how it differs from similar tools?

The description states a specific verb (set) and resource (current document), and clarifies its purpose for subsequent stateful operations. It also explicitly negates file creation, which helps distinguish it from creation tools, though it doesn't name sibling tools explicitly.

Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.

Does the description explain when to use this tool, when not to, or what alternatives exist?

No guidance on when to use this tool vs alternatives. The phrase 'for subsequent stateful operations' implies a prerequisite, but there are no explicit conditions, exclusions, or references to sibling tools like ms_gui_create_current or ms_gui_import_current.

Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.

Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?

No annotations provided. The description says 'in place' implying mutation, but does not disclose side effects, required document state, or any destructive behavior. Minimal transparency.

Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.

Is the description appropriately sized, front-loaded, and free of redundancy?

The description is a single sentence, concise but under-specified. It earns a middle score due to brevity, but lacks necessary details.

Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.

Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?

With 9 parameters, no output schema, and no annotations, the description is severely incomplete. It fails to explain parameter usage, units, or behavior, making it inadequate for correct agent invocation.

Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.

Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?

Schema description coverage is 0%, and the description does not mention any parameters. The 9 parameters (a, b, c, alpha, beta, gamma, exportFile, ballAndStick, documentName) are completely undocumented in the description, providing no semantic guidance beyond the schema.

Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.

Does the description clearly state what the tool does and how it differs from similar tools?

The description clearly states the action (set) and resource (lattice parameters on current GUI crystal document, in place). It is specific enough to distinguish from other GUI tools like create or make supercell, though not explicitly differentiated from siblings.

Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.

Does the description explain when to use this tool, when not to, or what alternatives exist?

No guidance provided on when to use this tool vs alternatives (e.g., creating a new crystal or modifying via other tools). No prerequisites or conditions mentioned.

Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.

Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?

No annotations are provided, so the description carries the transparency burden. It discloses the folder-creation behavior, workspace scope, naming convention, and a safety condition ('only when explicitly asked'). It does not fully catalog all session-switching side effects, but the schema's description of allowExistingSessionSwitch covers the prevention mechanism.

Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.

Is the description appropriately sized, front-loaded, and free of redundancy?

The description is two focused sentences with no filler. The core action and location are front-loaded, and the usage caution is placed directly after, making it easy for an agent to parse quickly.

Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.

Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?

For a tool with only two optional parameters, no output schema, and no nested objects, the description plus schema provide enough context to invoke it correctly. It covers the folder naming, workspace scope, and when not to use it; return-value details are absent but not critical for this low-complexity operation.

Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.

Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?

Schema description coverage is 100%, so the baseline of 3 applies. The description adds little parameter meaning beyond what the schema already says: folderName is optional and defaults to an auto-generated date-based name, and allowExistingSessionSwitch guards against accidental switching. No additional semantics are needed.

Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.

Does the description clearly state what the tool does and how it differs from similar tools?

The description opens with a precise verb+object: 'Start a new MS-MCP task/session folder under the workspace,' and includes the naming pattern (YYYY-MM-DD-1) plus its purpose ('for subsequent GUI modeling and calculation outputs'). This clearly distinguishes it from sibling GUI modeling tools by scoping it to session setup rather than modeling or calculation.

Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.

Does the description explain when to use this tool, when not to, or what alternatives exist?

The description explicitly states when to use it: 'Use only when the user explicitly asks for a new task/session.' It also gives an exclusion rule—normal modeling should reuse the Dashboard/current session—so an agent gets a crisp selection boundary without needing to infer it.

Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.

Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?

No annotations are provided, so the description carries the burden. It states the tool retrieves information (a read operation) but does not disclose any behavioral traits such as side effects, performance implications, or prerequisites. The description is accurate but minimal.

Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.

Is the description appropriately sized, front-loaded, and free of redundancy?

The description is a single, front-loaded sentence that efficiently conveys the core purpose. It is concise but could be slightly expanded to clarify what 'history' entails. Still, it earns its place without waste.

Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.

Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?

The description lists what the tool returns but does not provide details on the return format or structure, and there is no output schema. For a tool that aggregates multiple state pieces, more completeness would be beneficial. Among sibling tools, it is a query tool, but the description leaves some ambiguity.

Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.

Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?

The input schema has no parameters (empty properties), and schema description coverage is 100% (trivially). With no parameters, the description does not need to add meaning beyond what the schema provides. Baseline score of 4 is appropriate.

Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.

Does the description clearly state what the tool does and how it differs from similar tools?

The description clearly identifies the tool's purpose: retrieving the stateful GUI session target, listing specific elements (current document, exported file, last job, history). It distinguishes itself from sibling tools that perform actions on the GUI state.

Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.

Does the description explain when to use this tool, when not to, or what alternatives exist?

The description implies using the tool to query GUI state, but provides no explicit guidance on when to use it versus alternatives like ms_gui_apply_current or ms_gui_edit_current. There are no usage conditions or exclusions mentioned.

Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.

Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?

No annotations are provided, so the description must disclose behavioral traits. It only states 'list files' without indicating if the operation is read-only, has side effects, or requires authentication. The lack of transparency is significant for a tool with no annotations.

Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.

Is the description appropriately sized, front-loaded, and free of redundancy?

The description is a single short sentence, which is concise, but it sacrifices necessary detail. It is under-specified for an effective tool description, though no redundant information is present.

Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.

Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?

Given the tool complexity (2 parameters, no output schema, no annotations), the description is incomplete. It does not explain parameter usage, return format, or filtering behavior, leaving the agent without crucial information for correct invocation.

Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.

Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?

Schema description coverage is 0%, meaning parameters have no descriptions. The tool description does not mention parameters at all, providing no additional meaning for 'subdir' or 'maxFiles'. The agent cannot infer their semantics from the description.

Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.

Does the description clearly state what the tool does and how it differs from similar tools?

The description clearly states the tool lists files under the MS-MCP work root, providing a specific verb and resource. It is not a tautology and distinguishes from siblings like ms_status or ms_gui_project_dir. However, it lacks detail on whether directories are included or recursion behavior.

Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.

Does the description explain when to use this tool, when not to, or what alternatives exist?

No guidance on when to use this tool versus alternatives. The description does not mention context, prerequisites, or exclusions, leaving the agent to infer usage from the name alone.

Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.

Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?

With no annotations, the description must carry the behavioral burden. It discloses 'short-lived' and 'one-time' aspects, which is useful, but it does not explain side effects, token consumption, return behavior, or what happens on repeated issuance. The approval configuration sentence is system setup, not a behavioral trait.

Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.

Is the description appropriately sized, front-loaded, and free of redundancy?

The description is just two sentences with no fluff, and the core purpose is front-loaded. The second sentence about requiring approval is somewhat tangential but still concise and potentially useful.

Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.

Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?

Given the absence of annotations, output schema, and schema descriptions, the description is too sparse to allow reliable invocation. It lacks parameter meanings, usage context, and what to do with the issued token, making the tool under-documented for its moderate complexity.

Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.

Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?

Schema description coverage is 0%, and the description must compensate by explaining parameters. It does not interpret 'target', 'operation', or 'ttlSeconds' beyond a vague hint of 'short-lived' that maps to ttlSeconds. For a 3-parameter tool with no schema descriptions, this is a critical gap.

Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.

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 ('short-lived one-time token for one reviewed licensed calculation'), clearly indicating it is an authorization step for licensed calculations. It does not explicitly name sibling tools, but the purpose is distinct from calculation-running siblings like ms_forcite or ms_castep.

Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.

Does the description explain when to use this tool, when not to, or what alternatives exist?

The description implies this tool is a prerequisite for licensed calculations by targeting 'one reviewed licensed calculation', but it does not explicitly say when to use it versus alternatives or provide any when-not guidance. The note about requiring explicit approval is a configuration directive, not usage guidance.

Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.

Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?

No annotations provided. Description does not disclose whether the operation is read-only, requires authentication, or what happens if queues are empty or folders missing.

Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.

Is the description appropriately sized, front-loaded, and free of redundancy?

Single concise sentence with no redundancy. Could be more structured, but adequately conveys purpose with minimal words.

Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.

Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?

No output schema and no description of return values. Lacks information on what the user can expect after invoking the tool (e.g., list of queue folders or status messages).

Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.

Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?

Tool has no parameters, so schema coverage is complete. Description adds context by naming the specific resource being inspected, which is meaningful beyond the empty schema.

Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.

Does the description clearly state what the tool does and how it differs from similar tools?

The description specifies a clear verb 'Inspect' and resource 'optional MS-MCP GUI queue folders', distinguishing it from siblings like 'ms_status'.

Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.

Does the description explain when to use this tool, when not to, or what alternatives exist?

No guidance on when to use this tool versus alternatives such as 'ms_status' or 'ms_remote_castep_batch_status'.

Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.

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 signals a read-only operation via 'Read' and confines access to the work root, but it says nothing about maxBytes truncation, nonexistent files, non-text content handling, or whether any side effects occur.

Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.

Is the description appropriately sized, front-loaded, and free of redundancy?

The description is a single, direct sentence with no filler and the core action is front-loaded. It is concise, though the brevity partly reflects under-specification rather than a deliberate balance of completeness.

Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.

Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?

With no output schema and no annotations, the description must explain what the caller receives and how the tool behaves at boundaries. It does not mention the return value, truncation due to maxBytes, error behavior, or path restrictions beyond the vague 'work root.' For a two-parameter tool in a large sibling set, this is inadequate.

Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.

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 some meaning to 'file' by identifying it as a text output file under the work root, but it leaves 'maxBytes' entirely unexplained, including its default, maximum, and truncation behavior. This is only partial compensation.

Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.

Does the description clearly state what the tool does and how it differs from similar tools?

The description states a specific verb and resource: 'Read a text output file under the MS-MCP work root.' It clearly identifies the tool's function, though it does not explicitly differentiate it from sibling tools. None of the listed siblings appears to be a generic text-file reader, so the purpose is reasonably distinguishable.

Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.

Does the description explain when to use this tool, when not to, or what alternatives exist?

The description provides no when-to-use guidance or alternatives. It only constrains the file location to 'the MS-MCP work root,' which is a scope restriction rather than usage guidance. An agent is not told when to choose this tool over related status or GUI inspection tools.

Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.

Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?

No annotations are provided, so the description must disclose behavioral traits. It states what is read but fails to mention safety, authentication needs, side effects, or error behavior, leaving significant gaps.

Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.

Is the description appropriately sized, front-loaded, and free of redundancy?

The description is a single sentence with no extraneous words, making it efficient. However, it could be more specific without adding length.

Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.

Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?

For a tool with one parameter and no output schema, the description omits critical context such as return format, error conditions, prerequisites (e.g., batch must be submitted), and any side effects.

Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.

Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?

With 0% schema description coverage, the description should add meaning for the single parameter 'batchName'. It only references 'remote CASTEP batch' without clarifying the parameter's format, semantics, or how it relates to the batch.

Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.

Does the description clearly state what the tool does and how it differs from similar tools?

The description clearly states the action ('Read') and the specific resources ('local preparation markers, submission receipt, and downloaded result summary') for a remote CASTEP batch, effectively distinguishing it from sibling tools like ms_remote_castep_record_submission.

Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.

Does the description explain when to use this tool, when not to, or what alternatives exist?

The description implies usage after a remote CASTEP batch is prepared and submitted, but lacks explicit guidance on when to use versus alternatives or any prerequisites or exclusions.

Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.

Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?

No annotations are provided, so the description carries the full burden. It says 'Record one Materials Studio Job Control receipt', implying a write operation, but does not disclose whether the operation is idempotent, what happens on duplicates, or any side effects. It gives basic context but lacks depth on behavior.

Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.

Is the description appropriately sized, front-loaded, and free of redundancy?

The description is two sentences, front-loading the purpose and then the usage guideline. Every sentence is concise and to the point, with no verbose or redundant content.

Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.

Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?

Given the tool has 10 parameters, no output schema, and no annotations, the description is incomplete. It covers purpose and a specific use case but lacks parameter details, return value information, and full behavioral context. An agent would need additional information to use it correctly.

Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.

Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?

Schema description coverage is 0%, and the description only provides meaning for calculationName (via the usage instruction). Other parameters like jobId, gateway, status, etc., are not explained. The description adds minimal value beyond the schema.

Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.

Does the description clearly state what the tool does and how it differs from similar tools?

The description clearly states the tool records a Materials Studio Job Control receipt and specifies the context: for native_castep preparation, call after submitting XSD. It gives a specific verb and resource, but doesn't explicitly differentiate from sibling tools like ms_remote_castep_batch_status, though the purpose is distinct.

Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.

Does the description explain when to use this tool, when not to, or what alternatives exist?

The description provides explicit usage guidance: call once per calculationName after submitting XSD. It clearly indicates when to use the tool but does not mention exclusions or alternatives. This is still effective for an agent.

Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.

Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?

The description implies a read-only check but does not explicitly state whether it modifies state, requires authentication, or has side effects. With no annotations provided, the description carries the full burden, and it partially fulfills it by indicating 'check' but lacks detail.

Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.

Is the description appropriately sized, front-loaded, and free of redundancy?

Single, clear sentence front-loading the action and scope. No unnecessary words; every part earns its place.

Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.

Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?

For a simple status check with no parameters and no output schema, the description adequately covers the tool's function. It could detail return format or behavior, but contextually it is sufficient.

Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.

Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?

The input schema has zero parameters, so baseline is 4. The description adds meaning beyond the schema by specifying what the tool checks (paths, availability, workspace), which is sufficient for a parameterless tool.

Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.

Does the description clearly state what the tool does and how it differs from similar tools?

The description explicitly states the tool checks three specific aspects: Materials Studio paths, RunMatScript availability, and MS-MCP workspace. This clearly distinguishes it from sibling tools that perform actions like running scripts, queue management, or GUI operations.

Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.

Does the description explain when to use this tool, when not to, or what alternatives exist?

No explicit guidance on when to use this tool versus alternatives. However, the purpose implies it serves as a pre-check before other MS operations, so usage context is somewhat implied but not stated.

Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.