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 what the tool returns (signature, params, notes, examples) and that version selection defaults to latest, which is genuinely useful. It omits anything about lookup errors for missing operators, whether names are matched exactly or fuzzily, and whether version formats other than '2.6' are accepted.

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 resource scope front-loaded before the version caveat. Slightly better if the version sentence were tied to a use case rather than a bare syntax note.

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 output schema exists, so return values need not be explained, and the description correctly refrains. What remains missing is routing context against ten siblings — without it, an agent seeing list_operators, search, and get_operator together has no stated criterion for choosing this one.

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 documents pylops_version well (example format '2.6', default is latest) but leaves the required 'name' parameter undefined beyond the implication that it is an operator name — no guidance on exact spelling, casing, or module prefix. Roughly half the compensation is delivered.

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 ('Get') and resource ('signature, parameters, notes and examples of a PyLops operator'), and it enumerates the returned content. It implicitly distinguishes itself from sibling list_* tools (which list names) and from search, but never names those siblings explicitly.

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

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

No indication of when to call this versus list_operators, search, or get_solver/get_workflow. The agent must infer that this is the detailed-lookup counterpart of list_operators, and there is no mention of failure behavior for unknown names or unsupported versions.

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

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

With no annotations, the description must carry the behavioral burden. It usefully discloses the returned fields and the version-resolution rule (default = latest), but says nothing about failure behavior when the name is unknown, whether the name is case-sensitive, or how large the payload may be.

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, front-loaded with what is returned, followed by the one non-obvious parameter's behavior. Zero filler, though the line break makes the version note read as a tacked-on afterthought.

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 structure need not be spelled out, and the description still names the returned sections. For a simple two-parameter lookup this is nearly sufficient; only name-format and not-found behavior are 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%, so the description carries the param burden. It documents pyproximal_version well (version selector, default latest, example value "0.10"), but leaves 'name' undefined beyond the implied operator identifier — no format, casing, or canonical-name guidance.

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

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

States a specific verb ('Get') plus the exact payload — signature, parameters, notes and examples — of a named PyProximal operator. That is clearly distinct from list_proxperators and get_proxsolver by name alone, though the description never explicitly contrasts 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?

No when-to-use, when-not-to-use, or alternative is stated. It is inferable that you call this after finding an operator name (e.g. via list_proxperators), but the description leaves that entirely to the agent's 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 present, so the description carries the burden, but "Get" reasonably implies a read-only lookup and the sibling list_proxsolvers confirms the discovery pattern. It does not state behavior on an unknown solver name (error vs null) or resolve which version is actually consulted, which are the meaningful unknowns for this 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, front-loaded with the resource and returned fields, followed by the version note. The phrase "pyproximal_version selects the PyProximal version" is mildly circular but the surrounding format example and default justify 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 no further explanation. However, the required name parameter is undocumented in both schema and description, and no cross-reference to list_proxsolvers tells the agent where valid names come from, leaving a real gap for a lookup 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 coverage is 0%, so the description must compensate. It does this well for pyproximal_version, giving a concrete example format ("0.10") and stating that the default is latest, but it says nothing about the required name parameter (expected class name, casing, where to find valid values via list_proxsolvers).

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 ("Get ... of a PyProximal solver") and enumerates the returned content: signature, parameters, notes, examples. It does not explicitly distinguish itself from the sibling get_solver or get_proxoperator, so the agent must infer the domain split from the tool 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?

There is no guidance on when to call this versus list_proxsolvers (discovery) or get_solver (a similar lookup), and no prerequisites or failure conditions are mentioned. The only usage-like statement concerns the version parameter's default, which is parameter semantics rather than tool selection guidance.

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

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

No annotations are provided, so the description carries the full burden. It does disclose the payload contents (signature, parameters, notes, examples), which is useful, but says nothing about lookup failure behavior (unknown solver name), whether version strings are validated, or what happens when a version lacks the solver.

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 purpose front-loaded and the parameter nuance appended; nothing is wasted or buried.

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 output schema covers return values, so the description need not. However, for a two-parameter tool with zero schema documentation, the undefined 'name' semantics and the absent link to list_solvers as a discovery step leave meaningful 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. It does well for pylops_version, giving the format example '2.6' and the default behavior (latest), but leaves 'name' completely undefined — the agent must guess it is an exact PyLops solver identifier rather than a search term.

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 ('Get signature, parameters, notes and examples of a PyLops solver') and enumerates what is returned, which distinguishes it from list_solvers and get_operator. It stops short of explicitly contrasting itself with get_proxsolver or get_operator, which share the 'get_<thing>' shape.

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 guidance concerns the pylops_version default; there is no statement of when to call this instead of list_solvers (discovery) or get_operator (a different resource). An agent must infer the lookup-by-name workflow 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 burden. It does disclose the returned content and the version-resolution behavior (default = latest), which is genuine added context, but says nothing about lookup-failure behavior, case sensitivity, or whether results are cached/read-only.

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 no filler: the first front-loads what the tool returns, the second handles the only optional parameter. Nothing 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?

With an output schema present, the description doesn't need to explain return values, and it sensibly spends its budget on version selection instead. The remaining gap is the unexplained `name` parameter and failure behavior, which are minor but real for a 2-parameter 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 does well for pylops_version (gives a concrete format example '2.6' and states the default is latest), but the required `name` parameter is entirely unexplained — no hint about naming conventions 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 ('Get') and resource ('a PyLops workflow') and enumerates the payload (signature, parameters, notes, examples), which distinguishes it from get_operator/get_solver siblings. It stops short of explicitly contrasting itself with those siblings by name.

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: it is a name-based lookup, so an agent can infer it should be called after list_workflows returns a name. There is no explicit when-to-use, no statement that get_operator should be used for operators, and no note on what happens when the name is absent.

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

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

No annotations are provided, so the description carries the burden. It discloses that pylops_version defaults to the latest, which is useful behavioral context, but it does not mention pagination, permissions, or other operational details beyond the basic listing behavior.

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

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

The description is two short sentences with no wasted content. The primary purpose is front-loaded, and parameter details follow 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 low-complexity list tool with an output schema, the description covers purpose, both parameters, and the version default. It could be slightly more complete by noting how this relates to sibling discovery tools, but the essential information is present.

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?

Although schema description coverage is 0%, the description compensates by explaining both parameters: module is an optional filter with an example, and pylops_version selects the version with a default. It does not enumerate valid module names, but both parameters are meaningfully explained.

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: listing operator names, with an optional module filter and version selector. It is clearly distinct from siblings like get_operator, though it does not explicitly contrast with list_proxoperators.

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 'List operator names' and the optional module filter, but there is no explicit guidance on when to use this versus alternatives such as search or get_operator. The inclusion of pylops_version is helpful context but not a usage rule.

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 behavioral disclosure. 'List' implies a safe read operation and the version/default behavior is disclosed, but there is no explicit statement about side effects, remote access, pagination, or failure behavior; the output schema covers return structure.

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, front-loaded with the main action and resource, followed by the version parameter detail. There is essentially no wasted 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?

The tool is simple, the two parameters are explained, and an output schema exists so return values need not be described. Given no annotations, it could be slightly more explicit about read-only behavior, but it is complete enough to call 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%, but the description compensates well: it explains that module optionally filters results and that pyproximal_version selects the version with an example format and latest default. It does not give examples or allowed values for module, so it is not perfect.

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 PyProximal proximal operator names, with an optional module filter. It is clear enough to distinguish from solver/workflow listing siblings, though it does not explicitly name the nearest alternative such as list_operators.

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 two practical usage knobs: filtering by module and selecting a PyProximal version, with latest as the default. However, it does not state when to use this tool instead of siblings like list_operators or list_proxsolvers, leaving that 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 burden. Calling it a "list" implies a read-only operation, and the note that the version defaults to latest is genuinely useful behavioral context, but it never states there are no side effects and gives no indication of result volume or ordering.

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, the primary purpose and the filter front-loaded, with the version caveat after. No filler, though the line-broken formatting is slightly awkward.

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 both parameters are covered. For a simple two-parameter listing tool this is nearly sufficient; a brief note on how names relate to get_proxsolver would close the last gap.

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: it explains that module filters results (with a concrete example "primal") and that pyproximal_version selects the version with a "0.10" example and a stated default. Only the accepted string formats remain implicit.

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 ("List PyProximal solver names") plus its filtering scope, which separates it from siblings like list_proxperators and get_proxsolver. It does not explicitly contrast with list_solvers, so an agent might hesitate between the two.

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 optional module filter and the version-default note imply how to use it, but there is no explicit when-to-use guidance and no pointer to get_proxsolver for fetching details on a returned name. Usage is inferable 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?

No annotations are provided, so the description carries the burden. It discloses default behavior for pylops_version and implies a read-only listing operation, but does not explicitly describe side effects, matching behavior, or other operational constraints.

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

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

Very concise and front-loaded: the primary listing behavior is stated first, followed by the two parameter explanations. No unnecessary 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?

For a simple list tool with two optional parameters and an output schema, the description covers the essential behavior, filtering, and version default. Minor gaps remain around valid module names and version semantics.

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%, but the description compensates by explaining both parameters: module as an optional filter with an example, and pylops_version with an example and the default behavior. It still does not enumerate valid module or version values.

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

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

Clearly states the verb and resource: list solver names, with optional module filtering. It is easy to distinguish from get_solver, though it does not explicitly differentiate itself from other list_* siblings such as list_proxsolvers.

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 the optional module filter and the version parameter, but does not state when to use this tool instead of get_solver or other sibling listing tools. Usage is implied rather than explicitly guided.

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 a meaningful behavioral trait – that the latest version per package is the default – but says nothing about ordering, inclusion of non-indexed versions, or whether results are exhaustive.

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, front-loaded with the resource being listed and followed by the one behavioral detail that matters. A stray line break splits the text but 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?

An output schema exists, so return shape need not be explained, and there are no parameters to document. For a simple read-only listing tool, the description covers what is listed and the default behavior – only minor details like result ordering are absent.

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. Nothing in the description contradicts or complicates the empty schema, and the 'latest is default' note implicitly explains why no version argument is 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?

States a specific verb (List) and a precisely scoped resource (PyLops and PyProximal versions that have an index). The only vagueness is what 'have an index' means operationally, but the agent knows exactly which set of items it gets.

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?

'For each package the latest version is the default' tells the agent what it gets when no version is pinned, which is useful context for downstream calls. However, it never says when to call this tool versus alternatives such as get_solver or list_operators, leaving that inference to the agent.

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

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

With no annotations, the description carries the burden, and 'List workflow names' does imply a lightweight read with no mutation. It adds useful context that an unset version resolves to the latest, but says nothing about pagination, ordering, or whether names are fully qualified — gaps for a discovery 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, front-loaded with the core action and resource, with the version caveat placed after. Nearly zero waste; only mild thinning is the parenthetical aside, which still earns its place by defining the resource.

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 both optional parameters are at least addressed. What remains missing is guidance on module value format and the choice between this tool and get_workflow, which matters given ten siblings in the same namespace.

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 partially does: pylops_version gets an example format ('2.6') and a documented default, and module is identified as an optional filter. However, the accepted values/shape of module remain undefined 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 verb and resource ('List workflow names') and clarifies what a workflow is here ('inversion/decomposition helpers'), which alone distinguishes it from the operator/solver/proxoperator listings. It does not explicitly contrast with the closest sibling get_workflow, so the differentiation is implicit rather than spelled out.

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?

'optionally by module' implies the filtering use case, but there is no explicit when-to-use/when-not guidance and no mention of when to call get_workflow instead. The pylops_version note gives a default but not a rationale for choosing an older version.

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

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

With no annotations, the description must carry behavioral disclosure. It does state that search covers names and docstring summaries, lists kind categories, and says versions default to latest, but it omits matching behavior such as exact versus partial matching, case sensitivity, result ordering, and limits.

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 tool's purpose and then covers relevant parameter semantics compactly. The inline enumeration of kind values is slightly cramped 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?

The description gives enough information to invoke the tool with a query, kind, and optional versions, and the output schema covers return values. However, it lacks sibling routing guidance and does not fully disclose search matching behavior, which matters for correct selection and use.

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 defines the kind enum values that are not in the schema and explains pylops_version and pyproximal_version with examples and default behavior, though the query parameter is only implicitly documented as the search term.

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: search PyLops and PyProximal by name or docstring summary. It is clearly a search tool, but it does not explicitly distinguish itself from sibling list_* or get_* 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?

Usage is implied by the word 'search' and the kind filters, but the description gives no explicit guidance on when to use this tool versus list_operators, list_solvers, get_operator, or other siblings. There are no when-not-to-use conditions either.

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