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 conveys that this is a read-only lookup over the Dalamud API and what domain it covers, but says nothing about result limits, pagination, caching, or whether the index must be refreshed (relevant given the `refresh_cache` sibling).

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 verb and scope front-loaded, no filler. Slightly redundant in that the second sentence restates the nouns from the first.

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 two-parameter, zero-required finder with fully documented schema and no output schema, the description covers intent and domain adequately. Return-shape detail is absent but the description does name the categories of objects returned.

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

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

Schema description coverage is 100% and the enum values for `kind` are fully explained in the schema, including the default. The description adds no parameter-level meaning beyond what the schema already documents, so the baseline of 3 applies.

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 (find) and resource (event-related types and delegate subscription points), plus concrete examples of what is located (EventArgs classes, event enums, delegates). It is clear what the tool does, though it never distinguishes itself from the sibling `search`/`search_members`, which likely cover similar ground.

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?

"Useful for locating EventArgs classes, event enums, and delegate types used to subscribe to framework events" implies the usage context, but no when-to-use vs. when-not guidance is given and no sibling alternative (e.g. `search` or `get_type`) is named for the non-event case.

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

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

With no annotations, the description carries the full behavioral burden. It usefully discloses a non-obvious side effect: it fetches the type's members if not already loaded. However, it does not state read-only status, error behavior, or return format, leaving significant gaps.

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

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

Two concise sentences, front-loaded with the core purpose and followed by a relevant caching detail. Every sentence earns its place with no filler.

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

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

For a simple two-parameter documentation lookup with no output schema, the description is adequate but not complete. It does not explain what 'full documentation' includes or how errors are surfaced, though the purpose and caching behavior are covered.

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

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

Schema description coverage is 100%, so the schema already documents both parameters fully. The description adds no additional parameter meaning or syntax beyond what the schema provides, making a baseline 3 appropriate.

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

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

States a specific verb and resource: 'Get full documentation for a specific member on a Dalamud type.' This clearly distinguishes it from search_members or list_* siblings, though it does not explicitly name an alternative tool, 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?

The description gives no explicit when-to-use guidance, no conditions for choosing this over search_members or get_type, and no prerequisites. The phrase 'for a specific member' implies a use case but does not constitute real usage guidance.

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

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

No annotations are provided, so the description carries the full behavioral burden and largely does not meet it. It never states whether this is a safe read (implied), whether results are capped or paginated, whether nested/transitive namespaces are included, or what a returned entry looks like. Only the enumeration of included type kinds is genuinely informative.

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 verb and the scope constraint, with zero padding. Nothing to trim.

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

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

For a simple one-parameter read with no output schema, the description minimally suffices and even clarifies the kinds of members returned. However, with no annotations and no return-value contract, absence of any statement about output shape, ordering, or result limits leaves an agent guessing when interpreting the response.

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

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

Schema description coverage is 100% and the single parameter already documents itself with two concrete examples. The description implies namespace scoping but adds no format, casing, or nesting semantics beyond the schema. Baseline 3 applies.

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') plus resource ('all types (classes, interfaces, enums)') scoped to a specific Dalamud namespace. That is clear and distinguishable from get_type (single type) and list_namespaces (namespaces themselves). It stops short of naming a sibling for comparison, so it is a solid 4 rather than 5.

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

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

No when-to-use, when-not-to-use, or alternative routing is given. The only usage hint is implicit in the name and the 'in a specific namespace' phrasing. An agent must infer that this is the browse-a-namespace tool and not a substitute for search_members or get_type.

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 supplied, so the description carries the burden. 'Get' implies a read-only lookup with no side effects, and it does disclose what the response contains (properties, methods, events), but it never confirms read-only behavior, caching semantics, or whether a missing type errors versus returns empty.

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 front-loaded sentence with no filler; the resource and payload are stated immediately. It is appropriately sized, though the spare text is partly why behavioral and usage gaps remain.

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, the description does name the returned sections (properties, methods, events), which is the minimum needed. It stops short of describing result shape, pagination/truncation, or the interaction with the sibling refresh_cache, so it is adequate but not complete for a documentation-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 description coverage is 100% and the single parameter already documents both simple and namespace-qualified forms with examples, so the description adds nothing beyond the schema. Baseline 3 applies.

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 (Dalamud type) and enumerates the payload (properties, methods, events), so the agent knows this is the deep-detail lookup. It does not explicitly contrast itself with close siblings like get_member or get_namespace, leaving the differentiation to inference.

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: call it when you already have a type name and need its full surface area. There is no statement of when to prefer this over search_members, get_member, or get_namespace, and no prerequisites (e.g. cache freshness, refresh_cache) are mentioned.

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

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

No annotations are provided, so the description carries the burden, and it does disclose the return contents and the fact that this is a non-mutating inspection step whose purpose is gating a refresh. It omits any note on cost, rate limits, or side effects, but for a zero-parameter status read there is little else to disclose.

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 with no filler; the payload listing comes first and the decision guidance follows, so the agent gets scope before routing advice.

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 is the sole source of return-value information, and it enumerates the fields returned plus the intended follow-up action. It does not describe the response format or how counts are structured, which is a minor residual gap for a simple status tool.

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

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

The tool takes zero parameters, so per the rubric the baseline is 4. The description correctly says nothing about arguments, which matches the empty schema.

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

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

The description gives a specific verb ('Return') and enumerates the exact payload (build time, Dalamud version, namespace/type counts, lazy-member coverage), which is far more concrete than the bare name 'health'. It does not directly contrast itself with the other read-listing siblings, but the enumeration makes its scope unmistakable.

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

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

It states an explicit decision context: 'Use to decide whether to call refresh_cache', naming the alternative sibling and the condition that selects it. It stops short of stating when *not* to call it or listing other alternatives, so it is not a full 5.

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

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

No annotations are provided, so the description carries the full disclosure burden. 'List' implies a safe read operation and the filtering behavior is described, but nothing is said about result shape, pagination behavior, or cache interaction (notably refresh_cache exists as a sibling). Adequate for a simple read tool, but with clear gaps.

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

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

Two sentences, no waste, with the core action front-loaded and the discovery use case following. Every clause earns its place.

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

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

For a simple zero-required-parameter list tool with a fully documented schema, this covers what is needed to call it. With no output schema and no annotations, it could still say what a returned enum entry looks like, which is the only meaningful 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 100%, so limit, query, and namespace are already fully documented in the schema. The description only restates the filter intent ('optionally filtered by namespace or keyword') without adding semantics beyond the schema, so the baseline 3 applies.

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 all enum types in the Dalamud API') plus its optional filter scope. It is clearly distinguishable from siblings like list_namespaces, list_services, and search_members, which target different resources.

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

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

Gives concrete usage context with examples of what the enums represent (job IDs, inventory slots, addon names). It does not name alternatives or say when to prefer search over list_enums, so it stops short of explicit routing.

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

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

No annotations are provided, so the description carries the full behavioral burden, yet it discloses nothing about return shape, pagination, or whether the list is exhaustive or cached (a refresh_cache sibling exists). For a zero-annotation tool this is a meaningful gap.

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

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

A single front-loaded sentence with no filler. Every word ('list', 'all', 'available in the documentation') carries weight for a discovery tool.

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 source of information about results, yet it says nothing about what a namespace record contains or how results are ordered. Adequate for a trivial list call, but incomplete for an agent needing to chain into get_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?

The tool takes zero parameters, so there is nothing to document; the baseline of 4 applies. No parameter claims in the description to mislead.

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 all Dalamud API namespaces') with clear scope ('available in the documentation'). It does not explicitly differentiate itself from the sibling get_namespace or list_services, so an agent must infer the list-vs-fetch distinction from naming 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?

The listing intent implies a discovery role before calling get_namespace, but the description never states when to use it, when not to, or names an alternative. Usage is inferable but not spelled out.

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 supplied, so the description carries the full behavioral burden. It usefully discloses the default return set (interfaces only) and what includeDelegate adds, but says nothing about ordering, result volume, or return shape, and only implies read-only via the verb 'List'.

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, zero waste, with the scope and the default-return behavior front-loaded before the opt-in flag. Every clause earns its place.

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

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

For a zero-required-parameter read-only lister with no output schema, the description covers the essential contract: what it lists, from where, and the default versus opt-in result set. The remaining gap is sibling routing among list_enums/list_namespaces/search, which is not addressed.

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 100%, so both parameters are already documented in the schema; the description only restates the includeDelegate default. It adds minor meaning ('event-delegate types') but no syntax or format detail beyond the schema.

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

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

States a specific verb and resource (list DI-injectable services) and pins the exact source namespace (Dalamud.Plugin.Services), which distinguishes it from generic listing siblings. It does not explicitly name alternatives like list_enums or list_namespaces, so an agent must infer the boundary itself.

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

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

The description implies when to use it ('the primary namespace for plugin authors') and explains the includeDelegate switch, but never states when to prefer this over search, search_members, or list_namespaces. Usage is left to inference.

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

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

With no annotations, the description carries the full burden. It discloses the core action (re-crawl and rebuild local cache), but omits operational details such as network dependency, whether it overwrites existing cache, expected duration, and failure 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?

Two sentences, front-loaded with the action and followed by the usage condition. No 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?

For a simple zero-parameter maintenance tool, the description covers purpose and trigger adequately. It could mention network requirements or cache replacement side effects, but those are minor gaps.

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

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

The tool has zero parameters, so the baseline score is 4. The description adds no parameter information, which is appropriate since none exist.

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 (re-crawl, rebuild) and resource (local documentation cache, dalamud.dev). Clear but does not explicitly differentiate from the read-only sibling tools; it's obvious but not named.

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

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

Gives a clear condition for use: 'Use when docs seem outdated.' No alternatives or exclusions are mentioned, so it stops short of a full when/when-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?

No annotations are provided, so the description carries the full behavioral burden. It discloses only the result scope ('matching types from all namespaces') and says nothing about pagination behavior via limit, result ordering/ranking, or whether the underlying cache (a sibling is refresh_cache) can make results 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?

Two short sentences, zero filler, with the purpose front-loaded ahead of the return summary. Appropriately sized for a simple search tool.

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 should carry more: it summarizes the return as 'matching types' but never says what a result contains (name, namespace, signature) or how to page through results. Adequate but leaves real gaps for an agent with no other structured guidance.

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

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

Schema description coverage is 100%, so query, kind, and limit are already documented with examples and defaults in the schema. The description adds no further parameter meaning, which is the expected baseline when the schema does the heavy lifting.

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 (Search) and resource (Dalamud API documentation) with the mechanism (by keyword), so an agent knows it is a lookup tool. It does not explicitly contrast itself with siblings like get_type, list_enums, or list_namespaces, which would have made the boundary explicit.

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

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

The phrase 'by keyword' implies discovery-style usage versus the exact-lookup siblings (get_type, get_namespace), but there is no explicit when-to-use or when-not-to-use guidance and no alternatives named. Usage is inferred rather than stated.

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

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

With no annotations present, the description carries the full load and does disclose two meaningful traits: no network access is required, and result usefulness is bounded by what has already been cached via get_type. This completeness caveat is exactly the kind of behavior a search-over-cache tool needs surfaced. It still omits anything about result shape 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?

Three short sentences, front-loaded with the core action and scoped immediately after. Every sentence contributes something (scope, performance, cache dependency), though it is slightly more clipped than it needs to be given the missing result-format detail.

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

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

There is no output schema and no annotations, so the description is the only source of behavioral context. It covers invocation conditions and cache dependency but says nothing about what a result looks like or how hits are ranked, which is a real gap for a keyword search tool with four parameters.

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

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

Schema description coverage is 100%, so query, kind, limit, and namespace are already documented in the schema, including the default/maximum for limit and an example namespace. The description adds no syntax, matching behavior, or keyword-scope detail beyond what the schema states, so the baseline 3 applies.

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 (search) and resource (members), and enumerates what counts as a member (properties, methods, fields, events, constructors). It also scopes the search to 'all types that have already been loaded,' which separates it from get_type. It never explicitly contrasts itself with the sibling get_member, so the 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?

It states the operative condition clearly: the tool is fast, needs no network, and improves as more types are pulled in via get_type — effectively telling the agent to populate the cache first. It stops short of naming a when-not case or pointing to get_member for exact-name lookups.

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