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 two useful traits: the copy is 'fresh' (not an in-place edit) and overrides are interpreted in mm/Hz and SI material units. But it omits whether it mutates existing state, requires prior setup, or can fail, so significant gaps remain for a creation 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 short sentences, with the core action front-loaded and the unit caveat second. Nothing is wasted, though the extreme brevity is partly under-specification rather than disciplined 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?

For a model-creation tool with no annotations, no output schema, and an undocumented free-form parameter, the description is too thin. It does not say where the model is created, what the caller gets back, how it relates to the solver siblings, or what happens on invalid overrides.

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 single 'parameters' argument is a free-form anyOf map with no documented keys. The description partially compensates by stating the unit system (mm/Hz, SI material units) and that values are 'overrides', implying keys map to parameter names, but it never enumerates valid keys or the accepted value shape.

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 verb 'build' and the resource 'a fresh parameterised copy of the antenna example' give a concrete action, so the purpose is not a tautology. However, it never clarifies what a 'preliminary model' is or how this differs from siblings like run_cad_script, so an agent cannot easily distinguish it from other model-construction 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 statement of when to use this tool, no prerequisites, and no reference to any alternative such as run_cad_script or start_solver. The agent must infer the workflow context entirely.

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 never states that this is read-only, how results are ordered, whether an empty list is possible, or what happens if the job is still running or the id is invalid.

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 efficient sentence with the resource scope front-loaded and zero filler. Nothing is wasted, though there is little structure to speak of.

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 read tool with no annotations or output schema, the description is minimally adequate: it names what is returned. It omits error/empty behavior, ordering, and whether artifacts require the job to be 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 coverage is 0% and the single job_id parameter is never mentioned, but the phrase 'produced by the job' does imply the scoping semantics of that parameter. It adds marginal meaning without explaining the default value or format.

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 ('List') and resource ('model, result, table and preview files produced by the job'), enumerating the artifact categories. This distinguishes it from siblings like read_result_text or get_job_status, though it does not explicitly name a sibling it differs from.

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

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

The description gives no when-to-use guidance, no prerequisites (e.g. must the job have finished?), and no alternatives among the many siblings. Usage is only implied by 'produced by the job'.

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 does not state whether the tool is read-only, whether it mutates anything, what permissions it needs, or what the output looks like; 'Locate' weakly implies a lookup but is not explicit.

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

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

A single compact sentence with no filler. It is appropriately sized, though it could be front-loaded with a clearer statement of what is returned.

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

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

With no annotations, no output schema, and a vague one-line description, an agent cannot tell what this tool returns or what 'environment' means in this workflow. For a zero-arg discovery tool the description should at least describe the shape of the result.

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, which is the baseline-4 case: there is nothing for the description to clarify about inputs. No parameter-level information is needed or missing.

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 verb ('Locate') and a set of resources (FEKO components, supplied model, documented assumptions), which is more than a tautology. But 'Locate' is ambiguous for a tool literally named get_environment — it is unclear whether it returns paths, configuration, or metadata, and nothing distinguishes it from siblings like read_api or get_artifacts.

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 tool, what preconditions exist, or how it relates to siblings such as create_preliminary_model or run_cad_script. Usage must be entirely inferred from the name.

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 one significant behavioral trait — the call is non-blocking and safe to invoke during a long solve — plus that status is "persistent." It does not address permissions, error behavior, or what happens for an unknown/expired job id, leaving real gaps for a no-annotation 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?

One tightly constructed sentence with the resource (stage status/diagnostics) and the key constraint (non-blocking) front-loaded. 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?

With no output schema and no annotations, the description usefully names the returned categories (stage status, recent FEKO diagnostics) and the non-blocking behavior, which is enough for a simple status probe. It nonetheless leaves the job_id contract and error/expiry behavior unaddressed, so it is only minimally 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% for the single required job_id parameter, so the description must compensate and does not. It never clarifies job_id format, source, or whether it must refer to an already-started job, adding no meaning beyond the bare schema field name.

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: reading stage status and FEKO diagnostics. A domain-aware agent can distinguish this from siblings like start_solver or run_post_script. It does not explicitly name an alternative it might be confused with, but the purpose is clear.

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

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

"without blocking a long solve" implies the tool is meant to be polled while a solve runs, which is useful implied usage guidance. However, there is no explicit when-to-use vs. alternatives (e.g., get_artifacts or read_result_text) and no stated 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 disclosure burden. It reveals only that the API is 'installed', which implies local filesystem access, but says nothing about permissions, failure modes when the path or application is invalid, or whether search_term changes 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 sentence with the resource stated first and the example appended, so the reader gets the point immediately. It is tight, though arguably too terse given the documentation gaps it leaves.

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 with no annotations and 0% parameter coverage the description leaves an agent unsure which application strings are valid, what search_term does, and how to discover relative paths. For a 3-parameter lookup tool this is not enough to call 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, and it partly does: the example fixes the format of relative_path (object/rectangle.htm) and a valid application value (cadfeko). It never explains search_term or enumerates the accepted application strings, so two of three parameters remain 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 verb 'read' plus the resource 'installed CADFEKO/POSTFEKO 2026.1 API' identifies the domain, and the example clarifies that it fetches a specific documentation page by application and relative path. However, 'read ... API' is ambiguous on its own (retrieve documentation vs. invoke an endpoint), and nothing distinguishes it from the sibling script/artifact 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 statement of when to use this tool, no prerequisites (e.g. that the documentation must be installed locally), and no mention of alternatives among the many sibling tools. The presence of a search_term parameter hints at a lookup workflow but the description never explains it.

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

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

No annotations are provided, so the description carries the full burden, and it does very little. It never says whether this is a safe read, whether it requires an existing job, whether content is truncated, or what happens if the filename does not exist. Listing the accepted file categories is the only behavioral signal offered.

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 short sentence with no filler, and the core action is front-loaded. It is appropriately sized, though the brevity reflects under-specification rather than disciplined 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?

An output schema exists, so return format need not be described. But with 0% schema coverage on parameters and no annotations, the agent still lacks the meaning of job_id, the truncation semantics of max_chars, and any precondition linking this tool to a completed job.

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 all three parameters are undocumented structurally. The description partially compensates by naming the file categories (CSV, Touchstone, notes, diagnostics) that filename can target, but job_id and max_chars (including its truncation role and 16000 default) get no meaning from either source.

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 (read) and the resource types it can return (exported CSV, Touchstone, notes, diagnostics), which is more informative than a bare 'read file'. However, it does not differentiate itself from the sibling get_artifacts, which an agent would likely consider first when looking for job output 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 only usage hint is 'for analysis in the assistant,' which is vague intent rather than a condition for selection. There is no statement of when to use this versus get_artifacts or read_api, no prerequisites (e.g., job must have completed), and no 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, and it does disclose two real traits: execution is asynchronous and output lands in a new job directory. However, it says nothing about what is returned (e.g. a job id), whether the call blocks, or how to retrieve 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?

A single, front-loaded sentence with no filler. The parameter hint is appended efficiently after the core action, though the semicolon splice makes the sentence slightly dense.

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 annotations, no output schema, and 0% parameter description coverage, one sentence is thin. The agent is not told what the call returns, where the new job directory lives, or how to obtain results, which are essential for an async runner.

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. 'Provide Lua/text assets by filename' usefully explains that the assets map is keyed by filename, but script_text is left entirely unexplained 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 names a specific verb (Run), a specific resource (CADFEKO Lua), and qualifies scope with 'asynchronously in a new job directory.' This distinguishes it from run_post_script, though it never names the sibling 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?

There is no statement of when to use this tool versus run_post_script, get_job_status, or the other run_* siblings. The 'asynchronously' cue hints that polling via get_job_status follows, but that is inference, not 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 the full behavioral burden. It usefully discloses the solved-job precondition and the behavior of an empty script_text (falls back to the tested S11/impedance exporter), but says nothing about mutations, permissions, or how results surface.

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 with the core action front-loaded and the default behavior second. No filler, though the second sentence is arguably the more load-bearing information for the caller.

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 job-execution tool with no annotations, no output schema, and 0% parameter coverage needs substantially more than two sentences. The caller has no idea what model_base selects or what artifacts are produced.

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 3 parameters, so the description must compensate. It explains only the empty-script default for script_text; model_base (default 'mba_preliminary') and the required job_id are entirely 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+resource: 'Run POSTFEKO Lua in a solved job.' The 'post' qualifier implicitly separates it from the sibling run_cad_script, though it never names that sibling directly. An agent can tell what it does, just not explicitly what it is not.

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 'in a solved job' implies the precondition that a solver run must already exist, and the second sentence hints at the default path. However, there is no explicit when-to-use/when-not guidance and no routing away from run_cad_script or start_solver.

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 the key async trait: it returns immediately and results must be polled. It does not say what happens if the CAD job is not complete, what the immediate return contains, or whether a prior solver run is overwritten.

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, and the async contract plus the follow-up tool are front-loaded so an agent knows the pattern immediately.

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 fire-and-poll tool the essential flow is conveyed, but with no output schema, no annotations, and entirely undocumented parameters, the description should say more about the immediate return value and failure modes before it is fully callable.

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% across three parameters, so the description must compensate and does not: cores (default 4), model_filename (default mba_preliminary.cfx), and job_id are never explained. Only a loose hint that job_id refers to a CAD job exists.

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+resource: starting the FEKO solver inside an already-completed CAD job. It differentiates the tool from siblings by naming get_job_status as the follow-up rather than doing the work itself, though it does not contrast itself with run_cad_script or run_post_script.

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?

"in a completed CAD job" states the precondition for calling it, and "then poll get_job_status" names the next tool explicitly. There is no explicit when-not guidance, but the sequencing is unambiguous.

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