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

No annotations are provided, so the description carries the full burden, and it delivers real behavioral context: fix_* constrains DOFs while assign_* only sets values, loads with modulus+direction apply along a vector, and 'variable' overrides the kind default. It does not say whether existing blocks are overwritten, whether the file is written in place, or what validation is required, leaving some mutation-behavior ambiguity.

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?

It is dense and front-loads the core action and the enumeration of kinds before the routing note. Every sentence carries semantic weight, though the kind list is long and slightly linear rather than grouped.

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?

Output schema exists so return values need not be described, and the mutation semantics, kind taxonomy, and sibling routing are covered. The gaps on interval/process_list and overwrite/validation behavior keep it short of fully complete for a 10-param mutation tool with no annotations.

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 0%, so the description must compensate, and it explains kind, stage, value, modulus, direction, and variable in meaningful terms. However, interval, process_list, model_part, and parameters_file receive no explanation anywhere, so a quarter of the parameters remain 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?

States a specific verb (insert) and resource (boundary condition / load process block into an existing ProjectParameters.json), and names the sibling it does not cover. An agent can distinguish it from project_add_process without opening either schema.

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 routes the agent: 'Use project_add_process for any other Kratos process.' It also gives selection criteria between kinds (fix_* vs assign_*, loads with modulus+direction vs value-based, when to pass 'stage'). Both the when and the when-not are stated.

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 transparency burden. It discloses important behaviors, such as which parameters are required per format (e.g., 'vtk' needs output_path, 'point' needs position and output_file) and the default for variables. However, it does not describe return values, side effects on the file, or error conditions, so transparency is only partially addressed.

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 concise and front-loaded with the purpose. It efficiently packs format-specific requirements and defaults into a single, readable passage. The only minor issue is the slightly run-on phrasing, but it remains clear and unscattered.

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 annotations, and an output schema, the description is reasonably complete: it covers the core formats and required inputs, and notes the default for variables. Yet it leaves 'model_part' unexplained and does not address how the output schema might influence expected return values, so the overall context falls short of fully complete.

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 explains the meaning of several parameters (format, output_path, output_file, position, variables) and ties them to specific formats. However, it omits any explanation for 'model_part' and does not explicitly state that 'parameters_file' is the target file path, leaving some 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 tool's function: 'Add an output process to a ProjectParameters.json.' It uses a specific verb ('add') and resource ('output process'), and enumerates supported formats with their distinct characteristics. This effectively distinguishes it from sibling tools like 'add_boundary_condition' by focusing on output configuration.

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 clear context about when to use the tool (to add an output process to a ProjectParameters.json) and explains format-specific requirements. However, it does not mention any alternatives or explicitly state when not to use this tool, leaving the user to infer distinctions from sibling names.

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 and does so richly: remeshing happens ONCE at setup before the solver initializes, the driving field must already be on nodes via mdpa NodalData, node/element renumbering consequences, and incompatibility with checkpoints and MPI. This is behavioral context far beyond a bare signature.

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?

Front-loads what the tool does before the strategy details and constraints, and every sentence carries information. It is dense with multi-clause sentences and runs fairly long, so it could be tightened, but there is no filler.

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 complex, high-stakes mutation of a config file, the description covers timing, prerequisites, failure modes, exclusions, and the offline alternative. An output schema exists, so return values need no explanation; nothing essential for calling this correctly is missing.

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 compensates well for the important parameters: it explains both strategy values (hessian=second derivatives, levelset=zero of signed-distance variable), the meaning of 'variable' and the required GRADIENT counterpart, and that min_size/max_size default to values derived from the current mesh. It does not explain model_part, freeze_sub_model_parts, or parameters_file, leaving those gaps.

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?

States a specific verb and resource ('Add an MMG remeshing process (MeshingApplication's mmg_process) to a ProjectParameters.json') plus the effect (mesh adapted while the case runs). It explicitly distinguishes itself from the sibling mesh_remesh, which is the alternative for offline refinement.

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?

Gives explicit when-to-use (adapt mesh during run, hessian vs levelset strategies) and when-not (remeshing inside the solution loop crashes solvers and 'is not offered'; cases with renumbering are refused by studies, checkpoints/resume, MPI launch, interactive sessions). It names the alternative mesh_remesh with the tradeoff.

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. It only says 'Configure' and 'before starting an isolated job,' giving no information about side effects, persistence, overwrite behavior, ordering constraints, or what 'serial single-stage' actually entails. This is inadequate for a tool that modifies checkpoint configuration.

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 economical sentence with the action front-loaded and no filler words. Some terminology like 'serial single-stage' is ambiguous, but the structure itself is appropriately concise.

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 five undocumented parameters, no annotations, and many siblings, the description is far too thin. The only useful contextual cue is the 'before starting an isolated job' timing, and the output schema does not compensate for missing parameter semantics and workflow prerequisites.

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?

There are five parameters and schema description coverage is 0%, so the description must compensate for missing parameter documentation. It does not mention case_dir, frequency, control_type, parameters_file, or max_files_to_keep at all, leaving an agent unable to infer required formats, units, or constraints.

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 action and object ('Configure serial single-stage checkpoint output') and a clear temporal context ('before starting an isolated job'). It is distinct enough from sibling tools like job_checkpoints to make the primary purpose understandable, though it does not explicitly name an alternative.

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 a clear usage condition: this tool should be used before starting an isolated job. It does not mention exclusions or compare against alternatives like job_checkpoints, but the timing guidance is explicit and actionable.

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, so the description carries the full behavioral burden. It does disclose real traits: static validation of the result, that 'parameters' causes a <name>.json file to be written, that 'sdof' data gets "location": "model_part" injected automatically, and default fallbacks for order/coupled_solver. It omits destructive/overwrite behavior on 'directory', prerequisites beyond the application, and failure modes.

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?

Front-loaded with the purpose sentence, then dense per-key explanations. It is long, but for an 11-parameter nested-argument tool nearly every clause earns its place; the only mild drag is the unbroken paragraph layout.

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?

An output schema exists, so return values need no explanation, and the description covers the hard nested structures and their interaction rules (ordering semantics, weak vs strong coupled_solver). Gaps remain on the scalar timing params and 'data_transfer_operators', which are the main incompleteness for a tool of this 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 coverage is 0%, so the description must compensate, and it substantially does: it documents the shapes of 'solvers', 'couplings', 'order', 'coupled_solver', 'convergence_criteria' and 'convergence_accelerators' with concrete examples. It leaves 'directory', 'start_time', 'end_time', 'num_coupling_iterations' and 'data_transfer_operators' undocumented, so it is strong but not complete.

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?

States a specific verb+resource: scaffolding a CoSimulation (coupled-solver) case where several solvers exchange interface data per time step. It even clarifies it runs via run_simulation like any case. However it never names or contrasts with the obvious siblings (create_fsi_project, create_multistage_project), so the agent must infer which case-builder to use.

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?

Gives context (run with run_simulation, needs KratosCoSimulationApplication) but no explicit when-to-use vs when-not-to-use, and no routing away from sibling project creators. Usage is implied through the coupling/solver structure rather than stated.

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 and does so well: it names every file written (ProjectParameters.json, fluid.mdpa, etc.), the five required Kratos applications, the ALE/Dirichlet-Neumann coupling behavior, and a concrete divergence condition. It falls short of 5 only because it is silent on overwrite/existing-directory behavior and return semantics.

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?

Dense but information-rich, front-loaded with the core purpose before elaborating geometry, meshing, coupling, side effects, and dependencies. Length is largely justified by the tool's complexity, though the single unbroken paragraph lacks visual structure for such a long definition.

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?

A rich output schema exists, so return values need not be explained, and the description supplies the dependency list, generated artifacts, and physical validity caveats an agent needs to call it correctly. The remaining gaps are the undocumented parameters and the absence of explicit sibling-selection guidance.

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, and it does substantially: it gives meaning to ramp_time, the [nx, ny] shape of fluid_divisions/wall_divisions, the accelerator option list, and couples wall_thickness/viscosity/length/E/fluid_height/time_step into a scaling relation. It leaves end_time, output_interval, dynamic_structure, poisson_ratio, wall_density, fluid_density, and max_coupling_iterations completely undocumented, so compensation is partial rather than complete.

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?

States a specific verb ('Scaffold') and a precisely defined resource: a partitioned FSI case with explicit 2D channel and elastic-wall geometry. It is unmistakably distinct from siblings like create_project, create_multistage_project, and create_cosim_project, which an agent can identify without opening any schema.

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?

Usage is implied by the tool name and the 'runs with run_simulation like any case' workflow pointer, and the stability caveat implicitly warns when NOT to expect success. However, it never explicitly says when to pick this over the sibling creators (create_project / create_multistage_project / create_cosim_project), leaving the selection decision to inference.

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 a higher burden. It goes beyond simple file-writing by explaining how presets fill constitutive_law and default variables, how user-supplied variables override preset defaults, and the optionality of constitutive_law. This adds meaningful behavioral context, though it does not mention file existence/overwrite behavior or potential 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 compact and front-loaded, starting with the action. The sentences are concise and each adds necessary detail: entry requirements, options, override behavior, and exception for thermal problems. No fluff or repetition.

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 moderate complexity of the nested materials structure and the presence of an output schema (so return values are covered), the description is largely complete for the tool's inputs. It does lack explicit statement about whether it overwrites existing files, but this is a minor gap for a write tool. Overall it provides sufficient context for correct usage.

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 does so effectively by thoroughly specifying the structure of each entry in the materials array, including required model_part_name, the choice of preset or constitutive_law, and the variables object with an example. It also implies the output_file parameter via the phrase 'Write a Kratos Materials.json'. This is far more informative than the generic 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 opens with 'Write a Kratos Materials.json', which is a specific verb+resource pair. It clearly distinguishes this tool from siblings like create_project_parameters, which writes a different file type. The additional detail about entries and presets further clarifies its scope.

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

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

The description provides clear guidance on how to choose between a preset and an explicit constitutive_law, referencing the sibling tool list_material_presets for preset names. It also explains when constitutive_law is optional (thermal problems). However, it does not explicitly exclude use cases or mention scenarios where using an alternative tool would be preferred.

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, and it does well by disclosing the orchestration mechanism (SequentialOrchestrator) and the nuanced mesh-sharing behavior: first stage imports mesh, later stages either reuse via matching model_part_name or import separately. It doesn't cover side effects like directory overwrites, but the key behavioral trait is well documented.

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 well-structured: it opens with the core purpose, then gives the stage format, then the orchestration context, and finally the mesh-sharing rule. Every sentence adds necessary information without redundancy. It is compact yet covers the essential details for correct usage.

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 tool is complex with 5 parameters and an output schema, but the description explains the most critical input semantics (stage structure and mesh sharing) in sufficient detail. It doesn't describe return values, but the presence of an output schema reduces that burden. Some parameter details are underexplained, but overall it is adequate for a knowledgeable user.

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 descriptions (0% coverage), so the description adds critical meaning by defining the 'stages' element structure: {"name": "<stage_id>", "template": "<template>", "overrides": {...}}. It also clarifies the role of model_part_name in mesh sharing. However, it doesn't explain 'create_demo_mesh' or 'stage_checkpoints', leaving some parameters unaddressed.

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 function with a specific verb and resource: 'Scaffold a Kratos multi-stage (orchestrated) case that chains several analyses in sequence.' It also gives concrete examples (continuation run, coupled workflow) and implicitly distinguishes from the sibling 'create_project' by focusing on multi-stage orchestration.

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 clear usage context by describing when to use the tool (for chained analyses) and how stages are structured. It also explains the mesh-sharing rule for selecting model_part_name, which guides correct setup. However, it doesn't explicitly state alternatives or exclude single-stage cases, so it falls just short of full 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 the demo mesh is wired to template defaults so the case runs out of the box, and that it returns created file paths and next steps. However, it does not mention potential side effects such as overwriting an existing directory or whether the operation is limited to an empty directory, leaving a transparency gap for a file-creating 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?

Two sentences, front-loaded with the core action, and no filler. Every clause adds value: the file types created, the optional demo mesh behavior, and the return value. Highly concise 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?

The tool is moderately complex (5 params, no annotations, output schema present). The description covers the main artifacts, the demo mesh option, and the return format, but omits guidance on how 'overrides' works or how to choose a template (e.g., referencing list_templates). It is adequate but not fully complete for a scaffolding tool.

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 only clarifies two parameters: 'template' implicitly (from a template) and 'create_demo_mesh' explicitly (optional demo mesh). It does not explain 'overrides' (a complex customization parameter), 'directory', or 'name', leaving three of five parameters largely 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 uses a specific verb ('Scaffold') and a specific resource ('complete Kratos case directory'), and explicitly names the files created (ProjectParameters.json + Materials.json). This clearly distinguishes it from sibling tools like create_project_parameters or create_materials, which focus on individual files.

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 context is clear: use this when you want a complete, runnable case from a template. It implies a higher-level alternative to the more granular sibling tools, though it does not explicitly name alternatives or say when NOT to use it. The optional demo mesh detail also signals the intended use case.

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 behavioral burden. It discloses key behaviors: generation from a template, overrides replacing defaults, conditional file writing, and that content is always returned. It does not mention overwrite behavior or error conditions, but it covers the main 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?

Three concise sentences, front-loaded with purpose, each providing actionable information without unnecessary words. The description is efficient and easy to parse.

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 simplicity, the presence of an output schema, and lack of annotations, the description covers the core workflow: template selection, overrides, writing to file, and return value. It could mention prerequisites or edge cases in more detail, but overall it is complete enough for the 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 0%, so the description must compensate. It explains template sourcing, the overrides format with a concrete example, and the output_file conditional. This adds meaningful semantics beyond the raw schema property types and titles.

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 'Generate a ProjectParameters.json from a template', identifying the specific verb and resource. It distinguishes itself from sibling tools like create_project and create_materials by focusing on parameter file generation, and references list_templates for sourcing templates.

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?

Provides clear usage context: use list_templates to find templates, use overrides to customize defaults, and use output_file to write to disk. It does not explicitly name alternatives or exclusions, but the workflow is well implied and the tool's role is clear.

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 burden of behavioral disclosure. It explains the tool reads an existing file and returns a structured summary with specific contents, also noting multi-stage cases are summarized per stage. It does not explicitly state it is read-only, but 'Parse' implies non-mutating behavior. Missing error handling or side-effect details, but overall transparent.

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-loaded with action, and every phrase adds value. The first sentence organizes the exposed information clearly, and the second provides a concise usage directive with no filler.

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 (parsing JSON, multi-stage support) and the existence of an output schema, the description covers the key aspects: what it parses, what it returns, and when to use it. It does not explain the output schema details, but that is covered by the schema itself. The description is complete enough for an agent to select and invoke the tool correctly.

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

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

The schema has one parameter `parameters_file` with no description (0% coverage). The description partially compensates by identifying it as an existing ProjectParameters.json, but does not specify path format, file vs. content, or other nuances. This is adequate but not rich.

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 function with a specific verb ('Parse... and return a structured summary') and a detailed resource (ProjectParameters.json). It enumerates the config aspects covered (analysis type, solver, etc.) and distinguishes itself from sibling tools like validate_project_parameters or create_project_parameters by focusing on understanding existing files.

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 context: 'Use this to understand a case you did not scaffold before editing or running it.' It implies the tool is for analysis before modifications, but does not explicitly name alternatives or state when not to use it, leaving some room for interpretation.

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. It discloses that the tool returns the graph and optionally writes it to output_file, and describes the round-trip behavior. It does not mention error cases or side effects beyond the explicit file write, but for this simple conversion it is adequately transparent.

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, each providing distinct value: the conversion action, the return/write behavior, and the round-trip relationship. It is front-loaded with the primary purpose and contains no 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?

The tool is simple with two parameters, and the description covers the input, output, optional file writing, and the inverse operation. Given the presence of an output schema, the return value is adequately addressed, and no significant context is missing.

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 0%, so the description must compensate. It explains that parameters_file is the ProjectParameters.json input, and that output_file is an optional destination for writing the graph. This adds meaning beyond the raw schema, though it does not specify that these are file paths.

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 converts a ProjectParameters.json into a Flowgraph graph.json for the Kratos FlowGraph editor. It names the specific action, input, output format, and differentiates from the sibling import_flowgraph_to_case by mentioning round-trip compatibility.

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 context is clear: this exports a case to a visual node editor graph. It mentions the round-trip with import_flowgraph_to_case, which serves as an alternative, but does not explicitly state when to use one over the other or list 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?

With no annotations, the description carries the full burden. It discloses that the tool returns the parameters and writes to output_file when provided, which covers the main behavioral traits. It does not mention error handling or overwrite semantics, but the core behavior is transparent.

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

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

The description is two sentences with no redundant words. Each sentence adds distinct information: the conversion purpose and the return/write plus round-trip behavior.

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 presence of an output schema and two simple parameters, the description covers the core purpose, both parameters, and the return/write behavior. It lacks details on error cases or specific format requirements, but for a conversion tool this 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?

Schema coverage is 0%, so the description must clarify parameter meaning. It identifies graph_file as the Flowgraph graph.json source and output_file as the destination when writing. This adds value beyond the bare titles, but it could explicitly name both parameters in one place for extra clarity.

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 ('Convert') and identifies both input (Flowgraph graph.json) and output (ProjectParameters.json), clearly distinguishing this from sibling tools. The round-trip note with export_case_to_flowgraph further differentiates it.

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 round-trip mention implies this is the inverse of export_case_to_flowgraph, giving clear context on when to use it. However, it stops short of explicitly stating when not to use it or naming alternative tools beyond that sibling.

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 behavioral burden and delivers unusually strong detail: SIGTERM escalating to SIGKILL after a grace period, and signalling of the entire process group so all MPI ranks stop. It does not cover permissions/auth or what happens if the job is already finished, but the termination mechanism and blast radius are clearly disclosed.

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 tight sentences, front-loaded with the action and followed by the operational details. No redundant restatement of the name or schema.

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 single-parameter mutation tool with an output schema present, the description covers the essential behavioral facts an agent needs. It could add whether cancellation is idempotent or what happens on an already-terminal job, but nothing critical is missing.

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% for the single job_id parameter, so the description technically must compensate; however, job_id is self-explanatory as an identifier and the description adds no format, source, or origin details for it. Minimum-viable semantics.

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?

States a specific verb and resource ('Cancel a running simulation job') and implicitly distinguishes itself from sibling cancel tools such as study_cancel by scoping to simulation jobs. An agent can identify the operation without opening the schema.

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?

Usage is implied by the name and purpose, but there is no explicit when-to-use guidance, no prerequisites, and no mention of alternatives such as job_resume or study_cancel. The reader must infer the 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 provided, the description carries the full burden of behavioral disclosure. It does disclose that the tool lists completed checkpoints and includes retained/deleted availability, which is useful behavioral context. However, it does not explain whether the operation is read-only, whether it requires specific permissions, or what the output structure looks like beyond the existence of an output schema.

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

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

The description is a single, concise sentence that front-loads the primary action ('List completed managed checkpoints') and adds a useful qualifier. It is appropriately sized for a simple list operation with one parameter.

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 tool has a simple input schema (one required parameter) and an output schema, so the description does not need to explain return values. However, with no annotations and no usage guidance, the description leaves some gaps: it does not clarify whether 'managed checkpoints' are job-specific, how to interpret retained/deleted availability, or how this relates to sibling tools like configure_checkpoints.

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 undocumented job_id parameter. The description does not explain what job_id refers to or how to obtain it, but the parameter name is self-explanatory in context. The description adds no semantic detail beyond the schema, so a baseline score of 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 a specific verb ('List') and resource ('completed managed checkpoints'), and adds a scope qualifier ('retained/deleted availability') that distinguishes it from generic checkpoint tools. It does not explicitly name a sibling alternative, but the verb+resource combination is clear enough to identify the operation.

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 context: it lists completed managed checkpoints and includes availability status, so an agent can infer it is for inspecting checkpoint history. However, it does not explicitly state when to use this tool versus alternatives like configure_checkpoints or job_status, nor does it mention 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. 'List' implies a read-only operation, and the state filter is disclosed. However, it does not detail the response format, ordering, scope of 'known' jobs, or any other behavioral traits, limiting 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 that is front-loaded with the verb and resource, and every word contributes meaning. There is no redundancy or filler.

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 simple tool with one optional parameter, and the description covers its purpose and filtering capability. An output schema exists, so return values do not need to be described. The description is complete for an agent to invoke the tool correctly.

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

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

The schema has no descriptions (0% coverage), but the description compensates fully by explaining the 'state' parameter and enumerating its allowed values (queued, running, succeeded, failed, cancelled). This adds essential 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 uses a specific verb ('list') and resource ('simulation jobs'), clearly stating the tool's scope ('all known') and an optional state filter. This distinguishes it from sibling tools like job_status, job_logs, and job_cancel.

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 clear context for when to use the tool (to list jobs, optionally filtered by state). However, it does not explicitly mention alternatives or when not to use it, though sibling tool names imply such cases.

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, so the description carries the full burden. It discloses tail/grep/rank behavior and the case-insensitive matching, but is silent on read-only nature, permission requirements, behavior for a still-running or missing job, and log truncation/rotation.

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 dense sentences, front-loaded with the core action, then the optional filters and the rank nuance. No filler text.

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?

An output schema exists, so return values need not be described, and the parameter semantics are covered. The remaining gap is edge-case behavior (missing/finished jobs, permissions) for a no-annotation tool.

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 coverage, the description compensates well: it defines tail as line count, grep as a case-insensitive substring filter, and rank as MPI rank selection with rank 0/unset meaning the main log. Only the obvious job_id is left 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?

States a specific verb and resource ('Return the last tail lines of a job's simulation log') plus the filtering modifiers. It also distinguishes itself from job_status by noting where rank_logs is enumerated, though it never explicitly frames itself against a sibling log-retrieval tool.

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?

Gives implied context (view a simulation log, use rank for MPI jobs, consult job_status for rank_logs) but offers no explicit when-to-use/when-not guidance or named alternatives for retrieving logs.

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?

Annotations are not provided, so the description must fully carry the burden of behavioral disclosure. The description says 'rerun from its preserved isolated input snapshot,' which clarifies the input source, but it does not disclose side effects (e.g., whether it overwrites output, requires permissions, or is idempotent) or the return behavior. The optional 'wait_seconds' parameter suggests a blocking behavior, but that is not explained. No contradiction with annotations, but significant gaps remain.

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

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

The description is a single, concise sentence with no redundant wording. It front-loads the primary action and resource. It earns a high score for efficiency, though it could be improved with additional context without violating 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?

Despite having an output schema (which could explain return values), the description leaves critical operational details unaddressed: the meaning of 'wait_seconds,' the relation to job state, and how this differs from 'job_resume.' Given the moderate complexity of a rerun operation and the presence of siblings, the description is insufficient for an agent to use the tool correctly without 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 schema only provides type and default for parameters. The description only mentions the 'preserved isolated input snapshot' concept, which relates to 'job_id' but does not explain how 'job_id' is used or what values are acceptable. 'wait_seconds' is entirely ignored in the description, despite being an optional parameter that likely controls blocking behavior. The description fails to compensate for the lack of schema documentation, so this is a significant 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 states a specific verb ('rerun') and resource ('job') and mentions the key concept of an 'isolated input snapshot,' which indicates the tool operates on a preserved snapshot. However, it does not distinguish this from the sibling tools 'job_resume' and 'job_cancel,' so an agent might confuse it with 'job_resume' which also relates to continuing a job. The purpose is clear but lacks 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 description provides no guidance on when to use this tool versus alternatives like 'job_resume' or 'job_status.' It does not mention prerequisites, such as the job being in a certain state or that the snapshot must exist. No exclusions or alternatives are named, leaving the agent to infer usage context, which is insufficient given the presence of related job-management siblings.

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?

There are no annotations, so the description carries the full burden of disclosing behavior. It only states that a new job is created; it does not say whether the original job remains, what side effects occur, whether this starts execution, or what wait_seconds/end_time affect. For a job-resuming mutation tool, this is a significant gap.

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

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

The description is a single, front-loaded sentence with no filler. It is compact and readable, though 'terminal isolated job' is somewhat jargon-heavy and could be expressed more plainly.

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 tool has four parameters, no annotations, and no parameter descriptions, so the short sentence is not enough for an agent to call it correctly. Since an output schema exists, return values are less of a concern, but the behavior and parameter semantics remain underspecified.

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 gives meaning only to checkpoint ('explicit job_checkpoints path'); job_id, end_time, and wait_seconds are left undefined in both the schema and description. An agent cannot determine how to set these parameters from the given text.

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 ('resume') and identifies the resource ('a terminal isolated job') plus the input mechanism ('explicit job_checkpoints path'). It is clear enough to tell this from generic job tools, though it does not explicitly contrast with the sibling job_rerun or job_checkpoints tools.

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 implies usage for terminal isolated jobs and on an explicit checkpoint path, which gives some context. However, it never states when to prefer this over sibling tools such as job_rerun or how it relates to configure_checkpoints/job_checkpoints, leaving the when-to-use decision partly to inference.

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. It discloses that the status is 'parsed from its log', a useful behavioral detail, and enumerates the possible states. It doesn't mention error handling or side effects, but the operation is clearly read-only and safe.

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, well-structured sentence that immediately conveys the tool's purpose and return values. There is no redundancy or filler, making it highly concise and easy to parse.

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 one-parameter status tool with an output schema present, the description is complete: it specifies what to pass, what the tool returns, and even hints at the underlying mechanism (log parsing). No additional context is necessary 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?

The schema has 0% description coverage for the only parameter (job_id), so the description must compensate. It adds context by referring to 'a simulation job' and 'its log', but does not explain the value's origin, format, or how to obtain it. This is minimal compensation, though the parameter name is self-descriptive.

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 the verb 'Get' and the resource 'state of a simulation job', listing the exact statuses and additional fields (elapsed time, current step/time). This distinguishes it from sibling tools like job_list and job_logs which handle different concerns.

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 clear usage: use this tool to obtain the status, elapsed time, and step/time of a simulation job. It does not explicitly mention when not to use it or name alternatives, but the scope is well-defined and distinct from siblings.

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 of behavioral disclosure. It implies a read-only operation by using 'Check' and 'report', and specifies what information is returned. However, it does not explicitly address side effects, error behavior, or system requirements beyond the basic check. This is adequate but minimal.

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

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

The description is a single, focused sentence that front-loads the main purpose ('Check that Kratos Multiphysics is available') and lists the key outputs. No unnecessary words are included, and it is immediately scannable.

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 zero-parameter tool with an output schema, the description provides sufficient context for an agent to understand its function. It covers what the tool checks and reports, and since there are no parameters or complex side effects, no additional detail is necessary. The presence of an output schema means return values need not be spelled out.

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 tool takes zero parameters, so the baseline is 4. The description adds value by describing what the tool reports (version, paths, thread count, compiled applications), which clarifies the output semantics beyond the empty schema. It does not need to explain parameters because there are none.

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 ('Check') and resource ('Kratos Multiphysics'), and clearly lists what it reports (version, paths, thread count, compiled applications). This distinguishes it from siblings like kratos_list_applications by focusing on installation availability rather than just listing.

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 is given on when to use this tool versus alternatives. There is no mention of prerequisites, follow-up actions, or why an agent would choose this over kratos_install or kratos_list_applications. The description only states what the tool does, not when to use 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?

With no annotations provided, the description carries the full burden. It discloses the parsing source (ValidateAndAssignDefaults block), the exact return contents, and error conditions (source unavailable, module not found, non-standard declaration). This is substantial behavioral context, though it doesn't mention performance or file-system dependencies.

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 front-loaded with the action ('Return...'), uses a compact dash list for contents, and includes only essential context (purpose, parameter source, error cases). No sentence is wasted.

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 only one parameter and no annotations, the description covers purpose, usage, parameter derivation, return contents, and error behavior. The presence of an output schema means return values need not be repeated. It's complete for an introspection tool.

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 schema provides only the parameter name 'python_module' with a title 'Python Module' and no description. The tool description compensates by explaining it takes a value from kratos_list_processes and provides concrete examples, giving the agent the needed semantics.

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 action ('Return a Kratos process' default settings') and details the contents (parameter names, default values, types, model-part references). It differentiates from sibling tools like kratos_get_solver_defaults by explicitly tying to process defaults and referencing kratos_list_processes as the source of python_module.

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 explains the tool provides the schema needed to author a process block in a ProjectParameters process list, which is a clear use case. It points users to kratos_list_processes to find valid python_module values, but does not explicitly state when not to use this tool in favor of 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 burden. 'Return' and 'as reported by GetDefaultParameters()' clearly imply a read-only query with no side effects. It doesn't discuss permissions or error handling, but for a getter this is acceptable and the output schema covers return 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?

Two sentences, front-loaded with the primary action, and no redundant information. Every clause earns its place, making it efficient and easy to process.

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 simplicity, the presence of an output schema, and the clear parameter guidance, the description is sufficiently complete. It could mention prerequisites like solver installation, but that is handled by sibling tools and is not critical for a getter.

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 schema has 0% description coverage, but the description adds meaning by explaining analysis_type as one of structural/thermal/fluid/potential_flow and solver_type as a value from kratos_list_solvers with examples. This compensates well for the schema 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 and resource: 'Return the complete default solver_settings parameters for a solver'. It clearly distinguishes from a sibling tool like kratos_get_process_defaults by focusing on solver defaults, not process defaults.

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?

Provides clear context by listing valid analysis_type values and directing to kratos_list_solvers for solver_type values. It implies when to use (to fetch solver defaults) but does not explicitly contrast with alternatives like kratos_get_process_defaults or state when not to use.

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, and 'look up ... whether each exists and its type' plus the non-obvious 'component_of' resolution ('DISPLACEMENT_X resolves to its array variable') give real behavioral context beyond a restatement. It still omits what happens for unknown names and whether an active session/installation is required.

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?

Front-loads the essential lookup semantics and ends with a concrete usage directive; the enumerated type list adds useful vocabulary. Slightly dense but every sentence carries 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?

For a simple single-parameter lookup with an output schema already covering the return shape, the description supplies purpose, usage context and the component_of nuance. The only real gap is error/failure behavior for names that do not exist.

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 clarifies that the parameter is a variable name and that lookup is by name, but never states that multiple names can be passed at once (the schema key is 'names'), leaving batching semantics to inference.

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?

States a specific verb and resource ('Look up specific Kratos variables by name') plus scope ('in the live build'), and the type-resolution detail distinguishes it from kratos_list_variables, which only enumerates names.

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?

Gives an explicit when-to-use: check names before putting them in ProjectParameters (variable_name, output variables, nodal_solution_step_data_variables). It names concrete downstream consumers, though it does not name the sibling alternative (kratos_list_variables) or state when-not to use 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?

With no annotations, the description carries the full burden. It discloses installation time, download size, immediate importability, and platform limitations. It does not mention what happens if an existing installation is present or overwritten, but it covers the key behavioral aspects beyond the bare 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 several sentences long but each sentence adds distinct value, from the core install action to platform caveats to post-install behavior. It is front-loaded with the main purpose and avoids unnecessary filler, though it could be trimmed slightly without losing essential 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?

Given the tool's complexity (platform constraints, package options, time/resource implications) and the presence of an output schema, the description provides strong contextual coverage: it tells the user what to expect during install, which platforms are supported, and that no restart is needed. The only gap is the undocumented 'upgrade' param and a lack of explicit return-value details, but the output schema partially covers the latter.

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 the parameters. It thoroughly explains 'applications' with examples and 'all' as a switch to the omnibus package, but it does not explain the 'upgrade' parameter at all. This leaves one of three parameters ambiguous, so the description only partially compensates for the missing schema descriptions.

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 specific verb and resource: 'Install Kratos Multiphysics via pip into this server's own Python environment'. It clearly distinguishes this from sibling tools like kratos_check_installation and kratos_list_applications by describing an installation action with a defined target environment.

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 on when to use the tool, including platform constraints (macOS requires a local build) and a preference for naming only needed applications to avoid large downloads. It does not explicitly name alternatives, but the guidance about when not to use it (macOS) and when to use the 'all' option is strong.

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. It discloses that the tool inspects the source tree and reports compiled status, but it does not explicitly state that the operation is non-mutating or mention any prerequisites (e.g., a valid source tree). This is acceptable for a list operation but lacks explicit safety/behavioral notes.

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, well-structured sentence that front-loads the main action ('List all Kratos applications') and then adds a useful qualifier. Every word contributes meaning; there is no redundancy or unnecessary detail.

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

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

Given the simplicity of the tool (no parameters) and the presence of an output schema, the description is quite complete. It explains both the scope (source tree) and the distinguishing behavior (compiled flag). It could possibly add a note about typical invocation scenarios, but overall 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 tool has zero parameters, so the baseline is 4. The description adds no parameter-level detail, but none is needed since the schema is already complete with 100% coverage.

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 function: listing all Kratos applications found in the source tree. It also adds a distinctive detail—flagging which ones are compiled/importable—which differentiates it from sibling tools that list elements, variables, or solvers.

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 this tool (when you need to see available Kratos applications and their build status) but does not explicitly state when to prefer it over alternatives or provide any exclusion criteria. This is adequate but not fully explicit.

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 of disclosing behavioral traits. The verb 'List' strongly implies a read-only operation, but the description does not explicitly confirm safety, state side effects (if any), or mention output format/pagination. It adds the filter availability but lacks detail on edge cases or permissions. For a simple listing tool, this is adequate but not rich.

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

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

The description is a single sentence, front-loaded with the main purpose, and includes only essential clarifying details. Every word earns its place; there is no fluff or repetition of schema 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?

With an output schema present, the description need not detail return values. It provides the resource type, the category of conditions, and the presence of filters. Given the simple nature of a list operation and the reference to sibling behavior, the description is complete enough for an agent to decide whether to invoke and understand the gist of what it returns.

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 mentions 'optional filters' and references the sibling tool for filter semantics, which adds some meaning. The parameter names 'application' and 'name_filter' are self-explanatory in the schema, but the description does not explicitly explain their allowed values or how they interact. The reference to kratos_list_elements is a helpful pointer, but not a full explanation.

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 condition type names registered in Kratos, with a specific scope (surface/line/point conditions used for loads and boundary terms). The verb 'List' and resource 'condition type names' are specific, and the parenthetical adds useful context. It distinguishes from the sibling kratos_list_elements by the resource type, even though it references the sibling for filter 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?

The description implies when to use this tool: when you need to enumerate condition types. The phrase 'optional filters as in kratos_list_elements' provides a pointer to sibling tool behavior, which is useful guidance. However, it does not explicitly state exclusions or alternative tools for other use cases, though the resource type itself makes the primary use case clear.

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 implies a read-only operation by using 'List' and gives examples, but it does not explicitly mention absence of side effects, error behavior, or any special constraints. For a simple listing tool, the description adds some clarity but not rich behavioral detail.

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

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

The description is a single, well-structured sentence that includes purpose, examples, and a filter reference. Every clause adds value and there is 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?

The existence of an output schema covers return values, and the low complexity of a list tool reduces informational needs. However, the lack of parameter semantics leaves a notable gap in the overall context. The reference to kratos_list_elements partially mitigates this, but the description is not fully self-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?

Schema description coverage is 0%, so the description must compensate by explaining the parameters. It only says 'optional filters' without detailing what the 'application' and 'name_filter' parameters do or which filters are supported. The reference to kratos_list_elements is indirect and does not make up for the lack of explicit 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 states the action ('List'), the specific resource ('constitutive law names registered in Kratos'), and provides concrete examples (LinearElastic3DLaw, Newtonian2DLaw). It distinguishes itself from sibling tools like kratos_list_elements by targeting constitutive laws specifically.

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 'with optional filters as in kratos_list_elements' explicitly references a sibling tool to indicate how filters are used, providing clear contextual usage. It implies this tool is for constitutive laws and that filter behavior matches an existing pattern, though it doesn't formally contrast with 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?

With no annotations, the description carries the full burden. It does disclose that the list is parsed from C++ macros, which adds source transparency. But it does not mention behavior like no results handling, whether it requires a local Kratos installation, or that it is a read-only operation (though 'list' implies read-only). The disclosure is adequate but not rich.

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

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

The description is two sentences with the main verb first, no redundant information. It efficiently explains the tool's purpose and both optional filters with examples, achieving high density of useful 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 simplicity, two optional parameters, and the presence of an output schema (which handles return values), the description is nearly complete. It covers purpose and all parameters. The only gap is not explicitly linking to sibling list tools, but this is minor since the resource type is clearly named.

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 descriptions for the two parameters (0% coverage). The description compensates fully by explaining 'application' as a filter by application name with an example, and 'name_filter' as a substring filter with a concrete example. This provides meaningful semantics beyond the bare 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 states a specific verb and resource: 'List element type names registered in Kratos', and clarifies the source ('parsed from KRATOS_REGISTER_ELEMENT macros in the C++ sources'). This clearly distinguishes it from siblings like kratos_list_conditions and kratos_list_variables by focusing on elements and the macro source.

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 clear context for when to use the tool: when you need a list of element types. It also explains the optional filters, giving concrete examples for application name and name substring. However, it does not explicitly exclude alternatives or direct users to sibling tools, but the purpose is unambiguous among the sibling set.

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 of explaining behavioral nuances. It discloses the best-effort nature of parsing defaults, the effect of 'with_defaults=true', and that modules failing to parse are still listed without defaults. However, it does not explicitly state whether the operation is read-only (though implied by 'list') or mention any potential performance implications.

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 four sentences, front-loaded with the primary purpose, and each sentence adds value: scope, usage context, default behavior, and an alternative tool reference. There is no fluff or repetition.

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 covers the main purpose, the optional defaults behavior, and points to a related tool for deeper schema needs. Since an output schema is provided, the lack of explicit return format is acceptable. Minor gaps remain around the filter parameters and whether the list is sorted, but overall it is reasonably complete.

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?

Input schema provides only titles (Application, Name Filter, With Defaults) with no descriptions, and schema coverage is 0%. The description explains the behavior of 'with_defaults' in detail but says nothing about 'application' or 'name_filter', leaving meaning heavily reliant on parameter names alone.

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 the verb 'list' and the resource 'Python process modules', and adds context about their use as 'python_module' values. It also distinguishes itself from sibling tools like kratos_get_process_defaults by explicitly pointing to that tool for single-module schemas.

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 states when to use the tool: when you need processes usable in ProjectParameters process lists. It also provides an explicit alternative: 'Use kratos_get_process_defaults for a single module's full schema', which clarifies the boundary between the two 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 carry the full burden of behavioral disclosure. It explains that the tool lists known solver_type values per analysis type and also scans for *_solver.py modules, which is informative. However, it does not disclose the effect of the optional analysis_type parameter (whether it filters results) or what happens when it is null, leaving a transparency gap.

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

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

The description is a single sentence that packs a lot of information: it lists the analysis types, the pairing with Python modules, and the additional scan for all *_solver.py files. It is front-loaded with the core action and avoids unnecessary words, but the sentence is somewhat long and could be split for readability.

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 tool is relatively simple, and the description conveys the main output: solver_type per analysis type and modules found. However, it fails to explain the role of the analysis_type parameter, which is a critical part of using the tool correctly. Given the output schema exists, return values are covered, but the missing parameter behavior leaves the description incomplete for a robust understanding.

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 one optional parameter (analysis_type) with 0% description coverage. The tool description does not mention this parameter at all, nor does it clarify whether providing an analysis_type filters the listing or how the default null behaves. This leaves the parameter's semantics unexplained, requiring the agent to infer from the tool name and 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 uses the specific verb 'List' and clearly identifies the resource: solver_type values per analysis type (structural, thermal, fluid, potential_flow), plus Python modules. This distinguishes it from sibling list tools like kratos_list_elements or kratos_list_variables, which target different entities.

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 makes it clear that this tool is for enumerating known solver types and their implementing modules, giving the agent enough context to select it when needing solver information. However, it does not explicitly mention when not to use it or point to alternatives, so a small deduction.

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 behavioral burden. It discloses that the list is 'introspected from the live build,' which is a key behavioral detail indicating the data reflects the current runtime state. It also explains grouping and filtering, providing useful context beyond a bare 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 only two sentences and immediately conveys the resource, grouping, source, and filter semantics. It is front-loaded with the core verb and object, and every phrase provides value without repetition or fluff.

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 that an output schema exists, the description does not need to detail the return structure. It sufficiently covers the source (live build), the grouping, and both filtering parameters. For a straightforward introspection/list tool, this is complete enough for an agent to select and 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?

The schema has 0% description coverage, but the description explicitly explains both parameters: type_filter selects a group and name_filter is a substring. This adds meaning beyond the bare schema. It does not mention edge cases like how the filters combine when both are provided, but the core semantics are clear.

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 ('List') and a clear resource ('Kratos variables') with examples of what is listed (DISPLACEMENT, TEMPERATURE) and how it is organized (by type). It clearly distinguishes this tool from sibling tools like kratos_list_elements and kratos_list_applications, which list different Kratos entities.

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: whenever you need to inspect available Kratos variables and filter them by type or name. It provides clear context but does not explicitly name alternatives or state when not to use the tool, so it falls short of the highest bar.

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

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

With no annotations, the description carries the transparency burden. It clearly indicates a listing operation, enumerates available presets, and explains the output's applicability as drop-in settings blocks. This goes beyond a bare 'list' by revealing the structure and purpose of the returned data.

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: one lists the presets, the second explains the drop-in usage. It is front-loaded, concise, and contains no filler 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?

For a simple list tool with no parameters and an output schema, the description is complete. It identifies the tool's purpose, enumerates the presets, and explains how the outputs are intended to be used in ProjectParameters. No critical context is missing.

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 tool has zero parameters, so the description need not add parameter details. The schema is already complete (100% coverage). A baseline score of 4 is appropriate; the description does not need to compensate for any missing parameter info.

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 'List curated linear_solver_settings presets' – a specific verb and resource. It enumerates the exact preset names for serial and MPI/Trilinos, distinguishing it from sibling tools like list_material_presets or list_templates.

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 states that each settings block is a drop-in for solver_settings.linear_solver_settings in a ProjectParameters, providing clear context for when this tool is useful. It does not explicitly name alternatives or exclusions, but the intended usage is evident.

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 does well: it discloses that each preset includes a constitutive_law name and default Variables, and warns that law names should be cross-checked with the compiled build via kratos_list_constitutive_laws. This is a meaningful behavioral detail. It does not mention return format or side effects, but for a list tool these are largely implicit.

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 core purpose. The second sentence adds valuable cross-check guidance. No filler or redundancy; 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 zero-parameter list tool with an output schema present, the description is complete: it explains what the presets are, what they contain, and how they should be used in a larger workflow (create_materials) while pointing to a validation step. It covers the essential context without over-explaining.

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 tool has 0 parameters, so the baseline is 4. The input schema is empty and schema coverage is trivially 100%. The description adds no parameter-specific semantics, but none 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?

Description states a specific verb ('List') and resource ('curated material presets'), with a clear usage context ('usable as preset in create_materials'). It also mentions that each preset carries a constitutive_law name and default Variables, distinguishing it from sibling list tools like list_linear_solver_presets.

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 a clear context: the presets are to be used as 'preset' in create_materials. It also instructs the agent to cross-check law names with kratos_list_constitutive_laws for the compiled build, which suggests a complementary tool. However, it does not explicitly contrast with all related list tools (e.g., list_linear_solver_presets), so it lacks explicit exclusion criteria.

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. It discloses what the output will include (descriptions, required applications, placeholder defaults), which is helpful. However, it does not explicitly state that the operation is read-only or free of side effects, though 'list' strongly implies it. More explicit safety disclosure would improve the score.

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 concise sentence that is front-loaded with the primary action and resource. It includes useful examples without unnecessary elaboration, and every word contributes to understanding.

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 no parameters and an existing output schema, the description fully covers the purpose and the nature of the returned data. It mentions the types of templates and the information provided with each, making it complete for an agent to select and invoke 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?

The tool has zero parameters, so the baseline is 4. The description does not need to explain parameters, and it correctly adds context about what is listed. No deficiencies in parameter documentation are present.

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 the tool's action ('List') and resource ('available case templates'), and provides concrete examples of template types (structural_static, thermal_transient, fluid_transient). This distinguishes it from sibling list tools that target different entities (applications, elements, etc.).

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 is provided on when to use this tool versus alternatives. It does not mention typical use cases (e.g., before creating a project) or when not to use it, nor does it reference sibling tools. The usage context is only implied by the tool's name and description.

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, so the description must carry the behavioral load, and it does well: it discloses the three concrete checks, the dependency on a Kratos build, the ordering side-effect of importing applications first, and the single-stage restriction. It is silent on failure/reporting behavior, but the output schema covers results.

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?

One dense sentence, but the checks and the applications guidance are front-loaded with the exclusion at the end. The em-dashes and parenthetical add useful specifics rather than padding, though the clause stacking is heavier than ideal.

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 an output schema present, return values need no explanation, and the description fully covers the check semantics plus the single-stage caveat. The only gap is the undocumented parameters_file argument, which is minor given its self-describing name.

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 0%, so the description must compensate. It explains the 'applications' parameter thoroughly, including format and a concrete example (["StructuralMechanicsApplication"]), but says nothing about 'parameters_file' beyond what its name implies. Half the parameters are clarified, so it is only partially compensatory.

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?

States a precise verb (cross-check) and the two resources being reconciled (Materials.json against the mesh), then enumerates the exact invariants verified. This separates it cleanly from siblings like materials_get, materials_set_property, and mdpa_validate without opening any schema.

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?

Gives clear context for invocation (pass application names so constitutive laws are imported first) and an explicit exclusion ('Single-stage cases only'). It does not name a specific alternative tool like validate_case or mdpa_validate, so it stops short of full when/when-not 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 provided, so the description carries the full burden. It does disclose the return content (one summary row per properties entry plus the raw document), which tells the agent the call is a non-mutating inspection and that output may be large because the raw document is included. It says nothing about permission requirements, missing-file/error behavior, or any size/pagination handling, so the disclosure is partial.

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?

One dense sentence, front-loaded with the verb and resource, followed by the return-shape detail. Nothing is wasted and there is no filler.

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?

An output schema exists, so return values need not be explained (though the description helpfully does so anyway). For a one-parameter read tool this is nearly sufficient; the remaining gap is the unspecified parameter format and how a missing or malformed file is reported.

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% for the single parameter 'materials_file', so the schema offers no semantics. The description only implies it is a Materials.json file, but does not specify whether the parameter is a full path, a bare filename, or resolved relative to the project, so it only partially compensates for the coverage 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?

Names a specific verb ('Read') and resource ('a Materials.json') and even enumerates the columns returned per properties entry, so the agent knows exactly what comes back. It does not name a sibling or the boundary against materials_check/materials_set_property, so it stops short of 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?

There is no statement of when to call this versus the sibling materials tools (materials_set_property, materials_remove_property, materials_check, create_materials). Usage is only implied by the verb 'Read'.

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 behavioral burden. It implies a destructive edit via 'Remove entries', but says nothing about persistence, whether the file is rewritten in place, reversibility, or what happens when no entry matches.

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?

A single tight sentence with the action front-loaded and no padding. It could be slightly clearer by separating the file argument from the filters, but nothing is wasted.

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?

An output schema exists so return values need not be explained, but for a mutation tool with zero annotation coverage and 0% parameter documentation, the description should say more about failure modes (no match, missing file) and side effects on the resulting Materials.json.

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 and it partly does: it clarifies that model_part_name and properties_id are optional filters combined with AND semantics ('all given criteria must match'). However it says nothing about the required materials_file parameter's format or path expectations.

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?

States a specific verb (remove), resource (entries in Materials.json) and the matching criteria, so an agent immediately understands it edits a materials file. It is distinguishable from siblings like materials_set_property and materials_get, though it never names them 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 explains the matching rule but gives no when-to-use context, no alternative tool to prefer for related edits, and no prerequisites (e.g., file must already exist, whether a validation pass like materials_check should precede 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?

With no annotations, the description carries the full behavioral burden and does so well: it discloses that the file is created if missing, how properties_id is auto-assigned, that preset fills the law/defaults then gets overridden, that existing entries are merged, and that replace=true rebuilds from scratch. It does not cover error/permission conditions or id-collision behavior, keeping it short of a 5.

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?

Front-loads the core action and primary key in sentence one, then layers behavioral detail with no filler. The prose is dense and slightly clause-heavy, but 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?

An output schema exists, so return values need not be explained, and the description thoroughly covers the mutation/merge semantics an agent needs. It omits failure modes and validation expectations (e.g., the role of materials_check), which for a write tool with no annotations would have been valuable.

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 0%, so the description must compensate and largely does: it explains preset, constitutive_law, variables, tables, replace, properties_id, and model_part_name semantics. It does not describe the internal structure of the free-form variables/tables objects or the materials_file path handling, leaving a gap for a nested-object-heavy signature.

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?

States a specific verb+resource ('Add or update ONE entry of a Materials.json'), the key field ('keyed by model_part_name'), and explicitly contrasts with the sibling create_materials. An agent can distinguish this incremental upsert from any of the ~90 siblings without opening the schema.

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?

Names the alternative and the condition that selects it: 'the incremental counterpart of create_materials, which rewrites the whole file.' It also routes the agent to list_material_presets for the preset argument, giving clear when-to-use context for both major choices.

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, so the description carries the full burden. It does disclose two genuinely non-obvious behaviors: property_id defaults to 1 and is invalid for geometries, and using sub_model_part silently adds the new entities and their nodes to that part plus all ancestors. It omits write-side behavior the agent needs: what happens to an existing file, what 'overwrite' toggles, and what errors occur on bad node ids.

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?

Four dense sentences with no filler; the kind enumeration is front-loaded and each subsequent sentence adds distinct information (entity_type naming, entity item shape, sub_model_part semantics). Slightly cramped, but nothing is redundant.

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?

An output schema exists, so return values need no explanation, and the description covers the core modeling semantics needed to construct a call. The gap is the required 'path' and the 'output'/'overwrite' file-handling parameters, which an agent must infer from bare schema property names.

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 0%, so the description must compensate, and it largely does: it defines the kind vocabulary, explains the entity_type naming convention and its node-count suffix, and spells out the exact per-item shape of 'entities' ([{nodes, id?, property_id?}]) plus the sub_model_part effect. It leaves three parameters undocumented – notably the required 'path' plus 'output' and 'overwrite'.

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?

Opens with a specific verb+resource: 'Add elements, conditions or geometries of one type,' immediately enumerating the three modeling object classes and clarifying the union-per-call constraint. This cleanly separates it from siblings like mdpa_add_nodes (nodes only) and mdpa_get_entities (read side) without needing the schema.

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?

Usage is strong on mechanics – it tells you the meaning of 'kind', how the entity_type suffix fixes node counts, and what sub_model_part does – but never states when to pick this over alternatives such as mdpa_set_entity_properties, mdpa_merge, or mdpa_get_entities, nor does it name any prerequisite (a valid path, existing node ids) or exclusion.

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 and does disclose real behavior: ids auto-default to the next free id, edits happen in place unless 'output' is given, and sub_model_part is optional. However, the 'overwrite' parameter is never mentioned, leaving a meaningful mutation-behavior gap.

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 tight sentences, front-loaded with the core action and format, then defaults and edit semantics. Every sentence carries information, though the flow could be marginally tighter.

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?

An output schema exists so return values needn't be described, and the description covers most call semantics. But for a mutation tool with no annotations and 0% schema coverage, the unexplained 'overwrite' parameter leaves the definition incomplete.

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 explains coordinates format, id defaults, and the dotted sub_model_part path, but says nothing about 'overwrite' or 'path', so it only partially covers the six parameters.

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?

States a specific verb and resource ('Add nodes to a .mdpa') with concrete format detail ([x, y] or [x, y, z]). This clearly distinguishes it from siblings like mdpa_move_nodes, mdpa_delete_nodes, and mdpa_get_nodes.

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 purpose implies when to use it (adding nodes to an existing mesh), but there is no explicit guidance on when to prefer a sibling such as mdpa_create_geometry_mesh or mdpa_create_structured_mesh, nor any stated prerequisites.

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 and does so well: it discloses split ratios, node handling ('mid nodes kept as unused nodes'), id preservation, sub-model-part propagation, name overrides, and that non-target cell kinds are untouched. It does not address auth, file-write side effects, or overwrite 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?

A single dense paragraph that is front-loaded with the core purpose and mode enumeration; each clause carries technical payload, though the packing of exception cases makes it somewhat heavy to scan.

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 mesh-conversion operation the description is thorough, and an output schema exists so return values need not be explained. The main gap is the unaddressed output/overwrite 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. It covers mode exhaustively and explains element_name/condition_name overrides, but says nothing about path, output, or overwrite semantics, leaving half the parameters 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 opens with a specific verb+resource ('Convert cell kinds') and enumerates each mode's exact transformation (quad_to_tri, hex_to_tet, quadratic_to_linear), so an agent can distinguish it from siblings like mdpa_transform or mdpa_extract without opening the schema.

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 clear motivating context ('Needed e.g. for the convection-diffusion solver, which requires simplices') and states that other cell kinds are left alone, but it names no explicit alternatives or when-not-to-use conditions.

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 behavioral burden and does substantial work: it discloses that a 'domain' part plus named boundary parts with conditions are created, the default condition/element types per dimensionality, the refinement/Laplacian-smoothing behavior, and the max_elements=200000 guard against runaway sizes. It does not explain what the overwrite flag does or what happens when the target path already exists, which is the main remaining gap for a file-writing 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?

Purpose is front-loaded in the first sentence, but the body is an extremely dense run-on block of kind/param text that is hard to scan. Much of the length is justified by 0% schema coverage, yet tighter formatting (per-kind lines, shorter clauses) would preserve the content with less parsing effort.

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?

An output schema exists, so return values need not be described, and the description is thorough about mesh generation semantics for a 6-param nested tool. It is nearly complete; only the overwrite behavior and path expectations are left unaddressed.

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 0%, so the description must compensate, and it does for most parameters: kind's five values are enumerated with their full params (r_inner, n_theta, vertices, holes, size_field, size_sources, etc.), and element_name/condition_name defaults are stated. 'overwrite' and 'path' are never explained, so the coverage is strong but not exhaustive.

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?

Specific verb + resource: generates a mesh for a parametric shape and writes it as a .mdpa file, with the parenthetical '(no gmsh needed)' clarifying the mechanism. It explicitly distinguishes itself from the sibling mesh_generate_gmsh, so an agent can route between them without opening either schema.

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?

Provides a clear alternative and selection condition: 'For CAD input or quality-driven meshes use mesh_generate_gmsh,' and the '(no gmsh needed)' clause implies when this tool is preferred. It stops short of naming when-not conditions against other siblings (e.g. mdpa_create_structured_mesh) or stating prerequisites like a valid workspace path.

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. It explains that the tool writes a .mdpa file, includes a 'domain' submodelpart, attaches boundary conditions to boundary parts, and provides default element/condition types. It does not cover error scenarios or file-overwrite behavior, but the key side effects and structural output are well described.

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 somewhat dense but well-organized: it front-loads the primary purpose, then breaks down variants and defaults. Every sentence contributes useful information, but the use of parentheses and list-like structures makes it slightly harder to parse quickly. It is appropriately sized for the 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?

Given the tool's complexity (7 parameters, multiple mesh variants), the description is complete: it covers all required parameters for each kind, optional parameters, defaults, submodelpart structure, and the fact that an output file is written. The presence of an output schema means return values need not be described. The agent has enough information to select and invoke the tool correctly.

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

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

The schema has 0% description coverage, so the description must compensate. It thoroughly explains the meaning of 'size' and 'divisions' for each variant (e.g., size=[W,H], divisions=[nx,ny] for rectangle), the optional 'triangles' flag, and the defaults for 'element_name' and 'condition_name'. Path, while not explicitly described, is self-evident from the verb 'write it as .mdpa'. This adds substantial meaning beyond the bare 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's function: 'Generate a structured mesh and write it as .mdpa.' It further specifies three distinct geometric variants (line, rectangle, box), which distinguishes it from sibling tools like mdpa_inspect or mdpa_validate. The verb 'generate' and resource '.mdpa' file make the purpose unambiguous.

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

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

The description provides clear context on when to use the tool: when a structured mesh is needed, and it details the supported kinds (line, rectangle, box) and their configurations. It does not explicitly contrast with alternatives or state when not to use it, but there are no direct sibling tools for mesh creation, and the context is sufficiently clear.

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, and it discloses meaningful behavior: the parent must already exist, entities wholly on the part's nodes are pulled in automatically, added entities drag their nodes in, and ancestors 'receive everything'. It leaves the interacting 'overwrite' parameter and failure modes unexplained.

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?

One dense paragraph, front-loaded with the core action and free of filler. It leans on nested parentheses and em-dashes that make it slightly run-on, but nearly every clause carries distinct 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?

An output schema exists so return values need no explanation, but for an 11-parameter, zero-coverage schema the description omits 'path', 'output', and 'overwrite', the last of which interacts with the documented exist_ok. Adequate on semantics, incomplete on the full parameter surface.

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% with 11 parameters, so the description must compensate; it directly explains selector, node_ids, include (with allowed values), exist_ok, and the element/condition/geometry id trio. The required 'path' and the 'output'/'overwrite' parameters are left entirely undefined, which is a real 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?

States a specific verb and resource ('Create a sub model part') and pins down the ambiguous part with concrete naming examples ('Structure_left', 'domain.fixed' for a child). It also implicitly distinguishes itself from mdpa_edit_sub_model_part by noting exist_ok 'extends an existing part instead of failing', so an agent can tell creation from editing.

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?

Gives actionable usage context: it points to mdpa_select_nodes for selector semantics and explicitly recommends include=['condition'] 'for a load surface'. It does not, however, state when an agent should prefer this over mdpa_edit_sub_model_part or what conditions make creation inappropriate.

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, and it does disclose a meaningful side effect: entities are removed from all sub model parts while nodes survive. It does not explain the overwrite/output behavior (in-place vs. new file) or whether the deletion is reversible, which matters for a destructive 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?

Two compact sentences with the action and target front-loaded, then the side effect. No filler, though the parenthetical kind enumeration could be folded more cleanly.

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?

An output schema exists, so return values need not be described. But for a six-parameter destructive operation with no annotations and no schema documentation, the missing semantics of path/output/overwrite leave the agent without enough to call it confidently.

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 clarifies the 'kind' values ('element', 'condition', 'geometry'), the role of 'ids', and 'sub_model_part', but leaves 'path', 'output', and 'overwrite' entirely unexplained despite 'overwrite' being defaulted in 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?

Specific verb+resource: 'Delete elements, conditions or geometries by id', and it names the two targeting modes (by id or by sub_model_part). The clause 'nodes are kept' implicitly distinguishes it from mdpa_delete_nodes, though that sibling is never named, so differentiation is only partially explicit.

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 conveys the two operating modes (delete by explicit ids, or delete everything belonging to a sub_model_part), which is genuine usage context. However, it never states when to prefer this over mdpa_delete_nodes or other edit tools, and offers no exclusions or prerequisites.

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 at all, the description carries full behavioral burden and does so well: it discloses the refusal precondition, what cascade additionally destroys (dependent entities), and the side effects (removal from every sub model part and from nodal data). It stops short of stating reversibility or whether the file is modified in place versus written via output/overwrite.

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 tight sentences, none wasted, with the core operation front-loaded before the conditional behavior. The only minor friction is the referent of 'They' in the final 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?

An output schema exists, so return values need no explanation. For a destructive mutation tool with zero annotation coverage, the description covers refusal and cascade well but omits what the output/overwrite parameters do and whether the deletion is reversible — gaps an agent would want before calling it.

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 usefully explains node_ids, selector, and especially cascade, but leaves path, output, and overwrite completely unexplained, so half the parameters remain 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?

States a specific verb and resource ('Delete nodes') plus the two accepted targeting mechanisms (id list or selector). The operation is unambiguous, but the description never differentiates itself from close siblings like mdpa_delete_entities or mdpa_get_nodes, so the agent must infer the boundaries from the name alone.

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 explains the key conditional path — nodes in use by elements/conditions/geometries are refused unless cascade=true — which is genuine usage guidance for choosing the cascade flag. However, it offers no explicit when-to-use-this-vs-an-alternative routing (e.g. versus mdpa_delete_entities), leaving the agent to infer the selection 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 the full behavioral burden, and it does disclose one important trait: the referential-integrity refusal condition. It says nothing about the mutation's permanence, whether it rewrites the input file or requires an 'output' path, or how 'overwrite' interacts with an existing target, 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?

Two short sentences, zero filler, with the core action front-loaded and the refusal constraint immediately after. Nothing to trim.

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?

An output schema exists, so return values need not be narrated. Still, for a destructive file-mutating tool with no annotations and 0% parameter coverage, the description is thin: it leaves the meaning of 'output' and 'overwrite' unresolved that the agent needs in order to call 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% across four parameters, so the description must compensate and largely does not. Only 'table' is inferable from the text; 'output' (a destination path?) and 'overwrite' (silently replace an existing file?) are never explained, and 'path' versus 'output' semantics are ambiguous.

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?

States a specific verb ('Delete') and a precisely scoped resource ('a top-level Begin Table block'), which is enough for an agent to distinguish it from mdpa_set_table or mdpa_get_data_blocks. It stops short of naming a sibling or alternative explicitly, so it lands at 4 rather than 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?

The clause 'Refused while a SubModelPart references the table' is a useful precondition that tells the agent when the call will fail, which is real usage guidance. However, there is no statement of when to prefer this over alternatives (e.g. mdpa_set_table, mdpa_delete_entities) or what to do about the referencing SubModelPart first.

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, and it does disclose key destructive semantics: 'delete' removes the whole part including children while entities stay in the mesh, and 'remove' also affects descendants. Ancestor propagation for 'add' is also noted. It does not mention permissions, rate limits, or whether edits are reversible/transactional.

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?

A single dense sentence organized around the action verbs keeps it front-loaded and mostly waste-free. It is information-rich but readable, with only minor reliance on parenthetical cramming.

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 an output schema present, return values need not be explained, and the destructive semantics of delete/remove are covered. But with 11 parameters at 0% schema coverage, the definition leaves several parameters (overwrite, output, the various id lists) undocumented for an agent that must supply them.

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, and it partially does by linking node_ids/selector to 'add', new_name to 'rename' (single word), and noting ancestors/descendants. However, most of the 11 parameters (output, overwrite, element_ids, condition_ids, geometry_ids) get no semantic explanation, leaving a substantial 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?

States a specific verb (edit) and resource (existing sub model part) and enumerates exactly what edit means via four actions (add/remove/rename/delete). Clearly distinguishes itself from sibling mdpa_create_sub_model_part, which creates rather than edits.

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 action list implies when each mode applies, but there is no explicit when-to-use vs. siblings such as mdpa_create_sub_model_part or mdpa_add_entities. The agent must infer that this operates on existing parts from the word 'existing' and from the delete semantics.

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 behavioral burden. It usefully discloses that the output is a new .mdpa file, what gets included, and that 'the input is untouched' (non-destructive). It omits any mention of the overwrite parameter's behavior, error conditions, or permissions.

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 tightly written sentences with the core action front-loaded and zero filler. It is efficient, though the enumerated list of included content is doing parameter/behavior work that could be structured more helpfully.

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?

Because an output schema exists, the return value need not be described, which the description correctly omits. However, for a file-producing mutation tool with zero annotation coverage and 0% schema description coverage, the description leaves overwrite semantics and the path/output distinction unaddressed.

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 and largely does not. The '(dotted path)' hints at the sub_model_part format and 'new .mdpa' hints at output, but path (the source file), output, and overwrite are never explained. Most of the four parameters remain undocumented in both schema and 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 gives a specific verb ('Write ... as a new .mdpa') and enumerates exactly what is extracted: entities, their nodes, children, and the root part. An agent can tell it produces a new standalone mesh file rather than inspecting or mutating one. It stops short of naming any sibling (e.g. mdpa_extract_boundary) to disambiguate from the other extraction/merge tools.

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 explicit statement of when to use this versus alternatives. The 'sub model part (dotted path)' phrasing implies the input domain and 'the input is untouched' implies a non-mutating extract, but with many siblings (mdpa_extract_boundary, mdpa_merge, mdpa_inspect) the description never says which condition selects this tool over them.

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 behavioral burden and does so well: outward orientation for positively oriented elements, the critical NOTE that a positive POSITIVE_FACE_PRESSURE acts along the outward normal (tension) requiring a negative value for compression, and that sub_model_part is created if needed. It omits overwrite semantics and any permission/error behavior, so not a full 5.

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?

Core purpose is front-loaded, followed by parameter guidance and then the important sign-convention NOTE. It is a dense single paragraph, which is justified by the complexity, though a small amount of parenthetical detail (node-count enumerations) could be tightened.

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?

An output schema exists, so return values need not be explained, and the description covers the substantive parameters and behavioral quirks for an 8-param, annotation-free tool. The unaddressed path/output/overwrite/property_id are relatively conventional, leaving only minor 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 coverage is 0% for 8 params, so the description must compensate. It explains condition_name thoroughly (Kratos type or a map keyed by face node count, with detailed node-count guidance for quadratic cells), plus element_part and selector. It leaves path, output, overwrite, and property_id undocumented, so it compensates for about half the parameters.

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?

States a very specific verb+resource: creating conditions on free (unshared) faces and placing them in sub_model_part. The parenthetical 'the way to get load/flux surfaces on a mesh that has none' clarifies intent, and it is readily distinguishable from siblings like mdpa_extract and mdpa_create_sub_model_part.

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?

Explains when this is the right tool ('a mesh that has none' load/flux surfaces) and describes narrowing behaviors via element_part and selector (with a concrete x=0 plane example). It does not explicitly name a competing sibling and defer to it, but the usage context is clear.

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