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

Annotations already declare readOnly, idempotent, non-destructive, and closed-world behavior, so the description's job is lighter. It adds the useful detail that references are 'installed house references' (local, not web), but says nothing about missing-workflow behavior, output shape, or size of the returned context.

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 purpose and followed by timing. No filler or repeated structured data.

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 read tool with no output schema, the description is barely sufficient. It omits what the returned context looks like and how large or structured it is, which matters for a context-composition 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 carry parameter meaning, yet it only alludes to 'one coding workflow' and 'optional NUI framework'. It does not explain what the workflow values select or what choosing a ui framework changes in the returned references.

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

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

States a specific verb and resource: reading installed house references scoped to a workflow and optional NUI framework. It is distinguishable from siblings like search_fivem_native or get_infrontofx_guidance, though the 'compose' framing is not fully explained.

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 timing hint ('Use before implementing or reviewing a FiveM resource') but never names an alternative tool or when-not to use it. An agent has to infer how this differs from get_infrontofx_guidance or get_infrontofx_skill.

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

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

Annotations already declare read-only, idempotent, non-destructive, and closed-world behavior. The description adds a meaningful authority caveat—that existing project instructions and the installed skill take precedence—but says nothing about the form of the returned guidance or whether it is static or versioned.

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

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

Two short sentences with the core action front-loaded and no wasted text. The authority caveat is efficiently stated, though 'focused guidance' remains vague.

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 tool, the annotations cover the safety profile and the description provides a precedence caveat. However, it leaves the topic semantics and return format undocumented, and gives no routing guidance relative to the skill-oriented siblings.

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, but it never mentions the required 'topic' parameter or its eight enum values. The enum values are largely self-descriptive, but the description adds no meaning about how topics map to guidance content.

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

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

The verb and resource are present ('Read focused guidance'), but 'guidance' is vague and the description never distinguishes this tool from close siblings like get_infrontofx_skill or search_infrontofx_skill. The second sentence clarifies authority but not what the tool actually returns or how it differs from the skill lookup.

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 does not state when to call this tool versus alternatives, nor does it mention list_infrontofx_topics for discovering valid topics. The note that project instructions and the installed skill 'remain authoritative' is a precedence caveat, not a usage condition for selecting this tool.

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

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

Annotations already declare readOnly, idempotent, non-destructive and closed-world, so the safety profile is covered. The description adds real context beyond them: a required INFRONTOFX_SKILL_ROOT environment prerequisite, the guarantee that arbitrary paths are never read, and the fact that output includes a content digest.

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 clauses with no filler, and the core action is front-loaded before the environment and path-safety caveats. Slightly awkward phrasing ('Read a selected reference directly ... with a content digest') costs a point but nothing is wasted.

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

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

For a single-parameter read tool with a rich annotation set and no output schema, the essential prerequisites and path-safety constraint are present. However, 'content digest' is undefined (checksum vs. summary) and the description never says how content is scoped or how sections are discovered, leaving gaps an agent would hit at call time.

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

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

Schema description coverage is 0% for the single `section` parameter, so the description must compensate; it only implies that the value names a reference to read. The enum of 24 topic-like values is largely self-documenting, but the description never explains what a 'section' maps to or how the valid values relate to the topics returned by list_infrontofx_topics.

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: 'Read a selected reference directly from the installed infrontofx-skill', which tells an agent this is a single-item fetch rather than a list or search. It does not distinguish itself from the similarly named sibling get_infrontofx_guidance, so the boundary between the two getters is left inferential.

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?

'A selected reference' implies the section must already be known, hinting that list_infrontofx_topics / search_infrontofx_skill come first, but no sibling is named and there is no explicit when-to-use or when-not statement. Usage is implied 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?

Annotations already declare this as read-only, idempotent, non-destructive, and closed-world. The description adds meaningful behavioral detail beyond those annotations by listing what is skipped: secret-named files, private/build/vendor directories, and symlinks. It also states that the tool returns findings rather than raw files, which is useful context.

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

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

The description is three short, front-loaded sentences with no filler. Scope, exclusions, and output behavior are each stated directly and 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 description covers the tool's operating scope, exclusions, and the general nature of its output, which is helpful given the rich annotations. However, with no output schema and 0% schema description coverage, it should do more to explain how the resource parameter identifies the target. The definition is usable but leaves a notable invocation 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?

The schema has zero description coverage for the single required resource parameter. The description never explains whether resource should be a name, relative path, absolute path, identifier, or something else, nor does it clarify how it relates to INFRONTOFX_RESOURCES_ROOT. This leaves an agent without the semantics needed to supply the parameter correctly.

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 operation on a named resource domain: read-only local triage inside INFRONTOFX_RESOURCES_ROOT. It also clarifies the output nature by saying it returns findings rather than raw files. It does not explicitly distinguish the tool from relevant siblings such as review_fivem_source or plan_fivem_resource, which keeps it below 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?

Usage is implied by the read-only local triage scope and the note that it returns findings instead of raw files. However, the description does not explicitly say when to choose this tool over siblings like review_fivem_source, plan_fivem_resource, or validate_fxmanifest.

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

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

Annotations already declare readOnlyHint, idempotentHint, and destructiveHint=false, so safety is covered. The description adds only the vague 'aligned with infrontofx-skill' scoping note and says nothing about what a topic contains, ordering, or pagination — notable since there is no output schema.

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

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

A single, front-loaded sentence with no filler. The resource and scope come first, and nothing is redundant.

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

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

With no params and no output schema, the description must carry the burden of explaining the return shape, and 'topics' is only loosely indicative. It is adequate for a trivial list call but leaves the agent guessing what each topic entry looks like.

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 no filtering or input is required, consistent with 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?

Names a specific verb (List) and resource (FiveM guidance topics) and adds a scoping qualifier ('aligned with infrontofx-skill'). However, it does not distinguish this from siblings like get_infrontofx_guidance or get_infrontofx_skill, so an agent cannot tell from the description alone which listing tool to pick.

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

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

There is no statement of when to use this versus the many sibling *infrontofx*/guidance tools, and no noted prerequisites. The phrase 'aligned with infrontofx-skill' hints at a relation but gives no actionable selection 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?

The annotations already declare readOnlyHint=true, idempotentHint=true, destructiveHint=false and openWorldHint=false, so 'Does not write files' is largely redundant. What the description does add is content-level behavior: the output is a house-style plan containing explicit validation steps. It does not say how complete the plan is, what sections it covers, or whether it depends on prior context.

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 zero filler, and the core purpose is front-loaded before the scoping caveat. Brevity is close to under-specification here, but nothing written 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?

With no output schema, the description carries the burden of explaining what the returned plan looks like, and 'house-style' plus 'explicit validation steps' is undefined. It also leaves both input parameters undocumented. For a planning tool feeding a downstream compose/preview flow, an agent cannot predict the response shape or how 'ui' changes it.

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

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

Schema description coverage is 0% for two parameters, so the description must compensate and it does not. The 'ui' parameter with its enum (none/vanilla/react/vue/svelte) is never mentioned, and 'name' is left to the schema's min/max length alone with no indication of naming conventions or how it shapes the plan.

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

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

States a specific verb and resource ('Return a ... FiveM resource plan') and adds a differentiating qualifier ('house-style ... with explicit validation steps'). It is distinguishable from mutating siblings, though it never names compose_fivem_context or preview_fivem_template, which occupy adjacent planning/rendering space.

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 is the negative 'Does not write files', which restates the readOnly annotation rather than telling the agent when to pick this over compose_fivem_context, preview_fivem_template, or inspect_fivem_resource. No prerequisites, no ordering, no exclusions tied to 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?

Annotations already declare readOnlyHint, idempotentHint, destructiveHint=false and openWorldHint=false, so the no-write claim largely restates them. The description does add that the target is a fixed canonical example rather than arbitrary resources, but it does not say what 'preview' returns or how output is shaped.

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

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

Two tight sentences with the core action front-loaded and the scope exclusion second. No filler, though the phrase 'resource/controller name' adds slight ambiguity rather than clarity.

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

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

For a single-parameter, read-only preview tool with no output schema, the description covers purpose, scope limits, and safety sufficiently. The only real gap is what the preview actually surfaces, which is minor given the fixed-example framing.

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 parameter is an undescribed 'name'. The description gestures at it with 'validated resource/controller name', which is a meaningful hint, but the slash phrasing is ambiguous about whether it identifies a resource, a controller, or both.

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 (preview) and resource (source files from the installed canonical house shop example). However, it does not distinguish itself from close siblings like review_fivem_source or inspect_fivem_resource, leaving the agent to infer whether it previews rendered output or raw files.

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

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

The negative clause 'does not write files or implement arbitrary requested features' usefully bounds scope, but there is no explicit statement of when to pick this over the sibling source-inspection tools. Usage is only implied.

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

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

Annotations already cover the safety profile (readOnly, idempotent, non-destructive, closed-world), and the description adds genuinely new behavioral context: the review does not execute code, does not prove security, and credentials should not be sent. The advisory-output caveat is exactly the kind of expectation-setting that annotations cannot convey.

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 with zero waste; the core purpose is front-loaded and each subsequent sentence adds a distinct constraint (non-execution, non-guarantee, credential hygiene).

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 should signal what a review returns (findings list, severity, matched patterns) and clarify the `side` parameter. The safety caveats are covered, but the agent still lacks enough to predict the response shape or fill `side` confidently.

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

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

Schema coverage is 0%, so the description must compensate, but it never mentions either parameter. "Pasted Lua/NUI source" loosely maps to `code`, yet the `side` enum (client/server/nui) is entirely unexplained — the agent cannot tell whether it selects the review perspective, the running context, or something else.

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 (review) and resource (pasted Lua/NUI source) with a qualifier that frames the output as pattern-based and advisory. It is distinguishable from siblings like validate_fxmanifest and inspect_fivem_resource, though it does not name them explicitly.

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

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

"Pasted source" and "advisory review" imply the usage context (code you already have, not a live resource), and the disclaimer sets expectations. However, no explicit when-to-use/when-not guidance or named alternatives are given, so the agent must infer routing versus validate_fxmanifest or inspect_fivem_resource.

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

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

Annotations already declare readOnlyHint, idempotentHint, destructiveHint=false and openWorldHint, so the safety profile is covered. The description earns credit for adding a concrete network boundary ('only to two fixed official index URLs'), which meaningfully narrows the broad openWorldHint, plus mentions API-set filtering and source links. It stops short of describing failure behavior when the network is unavailable.

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 filler, with the core action and resource stated first and the network constraint as a follow-on caveat.

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 should say what a result looks like; 'source links' is the only hint at return content. For a simple read-only search this is close to adequate, but the meaning of `side` and the shape of results remain unstated.

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 has to carry parameter meaning and only partly does: 'by name/hash' usefully clarifies the `query` field beyond a bare 2-100 char string, and 'API-set filtering' hints at `side`. The `limit` parameter and the exact client/server/any semantics of `side` are left entirely to the schema, and 'API-set filtering' is too vague to be reliable.

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) plus a precisely-scoped resource (the official GTA and Cfx native indexes) and names the lookup keys (name/hash). That is plainly a different resource class from every sibling (skill/topic lookups, resource inspection, fxmanifest validation), so an agent can route to it without ambiguity.

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 phrasing 'by name/hash' implies what kinds of queries are appropriate, which is light usage guidance. However, it never states when to prefer this over reviewing FiveM source code or inspecting a resource, nor any exclusions or prerequisites.

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

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

Annotations already establish read-only, idempotent, closed-world, and non-destructive behavior. The description adds useful context beyond that: it searches only 'approved installed-skill references,' uses 'literal terms' rather than semantic matching, and returns file and line locations.

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 phrase contributes: the search action, target corpus, matching mode, approval constraint, and return location format.

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

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

For a simple read-only search tool with no output schema, the description adequately covers purpose, scope, and return shape. However, it omits the limit parameter entirely and gives no usage alternatives, leaving minor but 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 carry the burden for both parameters. It clarifies that 'query' is a literal-term search, but the 'limit' parameter is not mentioned at all, leaving its semantics and constraints unexplained beyond the raw schema.

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

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

The description states a specific verb and resource: 'Find relevant house rules ... across approved installed-skill references.' This clearly separates it from retrieval-oriented siblings like get_infrontofx_skill and list_infrontofx_topics, though it does not name 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?

The description explains what the tool does but gives no explicit guidance on when to use it instead of get_infrontofx_skill, list_infrontofx_topics, or other siblings. The 'literal terms' phrasing implies a search use case, but no alternatives or exclusions are stated.

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

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

The annotations already declare readOnlyHint=true, destructiveHint=false, and idempotentHint=true. The description adds meaningful context beyond annotations by clarifying that the manifest is parsed 'without executing it' and that it inspects declared API, distribution and load order. It does not cover return values or error behavior, but the safety profile is reinforced.

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

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

The description is two sentences, front-loaded with the core action and immediately followed by the key non-execution constraint. Every sentence adds useful information and there is no redundant 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 one-parameter tool with rich safety annotations, the description covers the essential purpose and syntax constraint. However, because there is no output schema, the description could do more to explain what the parse returns or what validation errors look like.

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 schema does not explain the single 'code' parameter. The description partially compensates by indicating that the input is a pasted Lua manifest with Lua 5.3-compatible syntax, but it does not mention the maxLength constraint or provide further format details.

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

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

The description uses a specific verb and resource: 'Parse a pasted Lua manifest'. It further scopes the purpose by saying it does not execute the manifest and instead inspects declared API, distribution and load order. This clearly distinguishes it from sibling tools like review_fivem_source or inspect_fivem_resource.

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

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

The description implies when to use the tool by mentioning 'pasted Lua manifest' and 'Lua 5.3-compatible manifest syntax only'. However, it does not explicitly state when to choose this tool over siblings or when not to use it, so usage guidance is only implied.

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