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

With no annotations, the description carries the full disclosure burden, yet it says nothing about result shape, ordering, pagination behavior, default result count, or whether matching is substring or exact. The only behavioral hint is the '1000+ entries' scale, which weakly implies results may be truncated.

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 the verb and resource first and the concrete examples trailing; nothing is wasted. The stray '*' and parenthetical slightly interrupt readability but do not obscure the point.

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?

There is no output schema and no annotations, so the description is the only place an agent could learn what comes back and how 'limit' behaves, and it covers neither. For a search tool intended to feed subsequent code-generation steps, this leaves significant gaps.

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

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

Schema description coverage is 0%, so the description must compensate, and it only illustrates the 'keyword' parameter through examples ('log', 'alarm', 'modbus'). The 'limit' parameter is never mentioned, leaving its default and effect on results 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 names a specific verb (search) and resource (CAREL System.* library API of functions and function blocks) and gives the scale (1000+ entries). It is clear what the tool returns conceptually, though it doesn't state why an agent would pick it over the similarly named sibling stone_symbols.

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?

Sample keywords ('log', 'alarm', 'modbus') imply the intended usage pattern, so the agent can infer that free-text topical queries are expected. However, there is no explicit when-to-use vs. when-not-to-use guidance and no mention of sibling tools such as stone_symbols or stone_snippet that might overlap.

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 output behavior: structured errors/warnings and a flash.bin artifact path on success. It says nothing about build duration, whether artifacts/side-effect files are written, or whether failures are returned as errors versus thrown.

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, the action front-loaded and the return contract second. Nothing is repeated from the schema or padding.

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 return-value sentence is valuable given there is no output schema, but for a tool with two undocumented parameters and no annotations, the definition leaves the agent guessing about argument selection and preconditions.

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?

Both parameters have 0% schema coverage, so the description must compensate and it does not. The slash in 'solution/project' hints that either may be supplied, but never clarifies whether they are alternatives, mutually exclusive, or whether one is required.

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 ('Compile a solution/project') plus what it returns, so the agent knows exactly what the operation is. Siblings (stone_doctor, stone_solution_state, stone_target_connect) are visibly unrelated, so differentiation is implicit rather than stated.

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 when-to-use guidance, no prerequisites (e.g. must the target be connected first?), and no exclusions relative to stone_doctor or stone_solution_state. The agent must infer the workflow position of a build step.

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 cover behavior entirely. It usefully discloses that the check compiles a dummy solution, implying it is more than a passive read and may take time or touch the filesystem. It does not cover whether anything is persisted, how long it takes, or what a pass or fail result means.

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 sentence, front-loaded with the action, then the concrete checks. There is no filler, and the license-validation detail is attached to the check that proves it.

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 zero-parameter diagnostic tool with no annotations and no output schema, so the description should say more about what the result consists of and how to act on a failure. It names the checks but leaves the output shape and failure semantics unexplained.

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 correctly implies that no input is required, because the environment is probed directly.

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 ('Check') and resource ('STone environment') and enumerates the sub-checks: SToneCLI, IronPython API, and dummy-solution compilation for license validity. This clearly separates it from the sibling tools, which create, build, search, or generate; none of them diagnose the 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 diagnostic nature is implied by the name and the checklist enumeration, so an agent can infer it is a pre-flight or troubleshooting check. But there is no explicit statement of when to run it (before first build, after connection failures) or when another sibling is the better call.

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 mentions that compilation occurs and diagnostics are returned, but it does not disclose whether existing files are overwritten, what permissions are required, whether registration has side effects, or what happens on failure.

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 are front-loaded and free of waste. The core action and the return type are stated efficiently.

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 with no schema descriptions, no annotations, and no output schema. The description mentions diagnostics with field names but does not explain parameter roles, write semantics, or the build side effects, leaving important gaps for an agent invoking 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%, so the description should compensate for the four undocumented parameters. It only loosely implies that code and project are involved, leaving name and solution unexplained and adding little beyond the parameter names.

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 and resource: writing an .st source into a project, registering it, and compiling it. It is clear what the tool does, though it does not explicitly distinguish itself from related siblings such as stone_build or stone_pou_generate.

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 write-register-compile workflow, but the description does not state when to use this tool versus stone_build or other source-generation tools. There are no explicit prerequisites, exclusions, or 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 and delivers little: it doesn't say whether the skeleton is returned as text or written to a project/file, whether anything is validated or compiled, or what 'compiling' guarantees. The 'body stays yours' clause does usefully disclose that no implementation logic is generated, but that is the only behavioral fact given.

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, which is good structurally. However, its brevity comes at the cost of under-specification rather than efficiency — the one clause present is doing work that several omitted clauses should do.

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 6-parameter, zero-coverage, no-annotation, no-output-schema tool, the description leaves critical gaps: return format, whether files are created, and the meaning of most parameters. An agent could guess a call shape from the schema but cannot predict the result or side effects.

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

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

Schema description coverage is 0% across 6 parameters, so the description must compensate and largely doesn't. 'typed variable sections' hints at the variables array and 'body stays yours' hints that body is a pass-through, but kind, name, comment, and return_type are never explained, and accepted values for kind are unknown (no enum).

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: 'Generate a compiling PROGRAM/FUNCTION_BLOCK skeleton with typed variable sections'. It names the exact artifacts (PROGRAM/FUNCTION_BLOCK) and the scope (skeleton only, body left to the caller), which no sibling tool covers. No sibling differentiation is stated, but the stone_* siblings are clearly unrelated toolchain utilities.

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

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

There is no guidance on when to use this versus writing code by hand or using stone_snippet/stone_solution_create, and no prerequisites or preconditions are mentioned. The only hint of scope is the trailing clause 'the body stays yours', which implies the tool won't supply logic.

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 disclosure burden. It implies a read-only lookup, but says nothing about whether omitting the name returns all snippets, how the name matches, or what the returned data looks like — leaving key behaviors for the agent to guess.

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 short sentence, front-loaded with the core action and resource, with zero filler. It is efficient, but the brevity comes at the cost of the specification gaps noted elsewhere.

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 an undocumented optional parameter, no annotations, and no output schema, the description is too thin: it does not explain what the parameter does or what the agent receives back, so an agent must call it speculatively.

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

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

Schema description coverage is 0%: the single 'name' parameter is a bare string with no description. The tool description never mentions the parameter at all, so an agent cannot tell whether it is an exact snippet name, a substring filter, or a category.

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 pairs a specific verb ('Show') with a specific resource ('the IDE's own ST code snippets') and clarifies the value proposition ('exact statement spellings'). That makes it distinguishable from lookup-oriented siblings like stone_api_search or stone_symbols, though it never explicitly contrasts with them.

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

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

Usage is only implied: the parenthetical 'exact statement spellings' hints the tool is for confirming precise ST syntax, but there is no statement of when to prefer it over stone_api_search or stone_symbols, nor any exclusion guidance.

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

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

No annotations are provided, so the description carries the full behavioral burden. It discloses the return value ('solution path') but says nothing about permissions, overwrite behavior if the solution already exists, template validity, or 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 a single front-loaded sentence that states the core action and return value with no wasted text. Examples are included compactly.

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 mutation tool with no annotations, no output schema, and 0% schema description coverage, the description is too thin. It does not explain required versus optional parameters, directory behavior, or creation side effects.

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

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

Schema description coverage is 0% for all three parameters. The description only partially clarifies the 'template' parameter by naming examples ('BaseProject, EmptyProject, ...'), while 'name' and 'base_dir' remain undocumented.

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

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

The description states a specific verb and resource: create a new STone solution from a template. It is clear enough to distinguish this from state/build/file tools, but it does not explicitly compare itself to siblings such as stone_solution_state.

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

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

The description provides no guidance about when to use this tool versus alternatives, nor any prerequisites or exclusions. Usage is only implied by the word 'Create'.

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 exist, so the description carries the full burden. 'List' implies a non-destructive read, which is the only behavioral signal; nothing is said about whether the solution must exist on disk, what happens when the solution argument is omitted, or whether results are cached/stale.

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 zero filler; nothing is buried or repeated. Brevity is efficient, though it edges toward under-specification rather than wasted words.

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

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

With no annotations, no output schema, and an undocumented optional parameter, the description leaves key call-time questions unanswered: default solution resolution and the shape of the returned project/file/config listing. For an inspection tool that is the entry point to a workflow, more context is warranted.

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 'solution' parameter is undocumented and not required. The phrase 'of a .stone solution' hints that the parameter identifies the solution, but gives no format (path? name? .stone file extension?) or default behavior when omitted.

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?

Uses a specific verb ('List') with three concrete resources (projects, registered files, build configurations) scoped to a .stone solution. That clearly separates it from mutating siblings like stone_solution_create and stone_files_add, though it never names an alternative 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 call this versus stone_solution_create, stone_files_add, or stone_doctor, nor any prerequisite such as 'call after stone_solution_create'. The agent must infer from the name that this is the read/inspect step in the workflow.

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 one genuinely useful behavioral trait: the index reflects the *last build*, implying a build must have run, and that interfaces must be opted into. It says nothing about read-only semantics, what happens when no build exists, or result size/pagination.

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 returned content front-loaded and options deferred. The telegraphic phrasing ('types. Optional: query=substring') is efficient but verges on terse shorthand that could read ambiguously.

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 4-parameter tool with zero annotation coverage and no output schema needs more: the format of the returned index, the meaning of project vs solution, and the build prerequisite are all unstated. The description names what is indexed but not enough for an agent to call it confidently in all cases.

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 only partly does. It clarifies that query is a substring match and that interfaces is a boolean toggle, but project and solution — half the parameters — are 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?

States a specific resource and scope: a symbol index of the last build, enumerating POUs, member interfaces with types, variables, tasks and types. An agent can tell this is a post-build symbol lookup rather than a build or state tool. The verb is implicit and no sibling is named, 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?

No when-to-use guidance and no exclusions. It never contrasts itself with stone_api_search (searching API reference) or stone_solution_state (current solution state), which are the obvious alternatives an agent would weigh. The 'Optional:' line describes parameters, not usage 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 provided, the description carries the full burden of behavioral disclosure. It says to connect but does not describe connection persistence, authentication, failure behavior, side effects, or what the tool returns.

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

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

The description is a single front-loaded sentence with no wasted words, and the example is useful. However, its brevity contributes to under-specification rather than crisp completeness.

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

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

For a tool with two undocumented parameters, no annotations, and no output schema, the description is too thin. It does not explain the relationship between solution and connection_string or what an agent should expect after connecting.

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 both parameters, but it only gives an example connection string without mapping it explicitly to the connection_string parameter. The solution parameter is left completely 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 (Connect) and resource (STone to a target), with an example connection string that clarifies the target format. It does not differentiate this tool from sibling stone_solution_state or other connection-related operations, but the core action is understandable.

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

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

The description gives no guidance on when to use this tool versus alternatives, nor any prerequisites such as needing an existing solution or target availability. It only provides a bare example, leaving usage context 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?

No annotations are provided, so the description carries the full behavioral burden. It discloses that the operation reads a variable from a connected target, but does not describe permissions, return format, failure behavior, or whether the target must first be connected via stone_target_connect.

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

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

The description is a single front-loaded sentence with no wasted words. It is appropriately concise, though the brevity contributes to missing contextual detail elsewhere.

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 0% schema description coverage, the definition is too sparse for reliable invocation. It leaves the meaning of 'solution', requiredness of parameters, return value, and error behavior undocumented.

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 both parameters. It mentions 'variable' but does not explain the 'solution' parameter, whether either parameter is required, or what format the variable identifier should take.

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

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

The description states a specific verb and resource: read one variable from the connected target. It is clear and distinct from most siblings, but it does not explicitly differentiate itself from related tools such as stone_symbols or stone_solution_state.

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

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

The sentence implies a read operation against a connected target, but gives no explicit when-to-use guidance, prerequisites beyond 'connected target', or alternatives among sibling tools. It does not say when this tool should be selected over stone_symbols or stone_solution_state.

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