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

The readOnlyHint annotation already establishes that this is a safe read operation, and the description reinforces that with 'Read'. It adds some context about the output contents but does not disclose additional behavioral traits such as error behavior, rate limits, or what happens for unknown names. No contradiction with annotations exists.

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 deliver the entire specification: the first defines the resource and its contents, the second defines acceptable parameter formats. There is no filler or repetition of schema information.

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 present, the description properly lists what the response contains: signature, description, permissions, reasons it can return, first build, example, and related guides. Combined with the clear input syntax, this is sufficient for an agent to select and call the tool effectively.

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 only describes the runtime parameter, leaving the name parameter with no schema-level meaning. The description compensates fully by defining both accepted forms—qualified names and side-pinned names—with concrete examples. This gives an agent the precise input syntax needed to invoke the tool 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 verb and resource: 'Read one native's card', and enumerates exactly what the card contains. It clearly distinguishes itself from broader sibling tools like open77_search and open77_guide by focusing on a single native's full documentation.

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 clear context: this tool should be used when you need the full card for a specific Lua native, and it explains the accepted input forms. It does not explicitly mention alternatives or when-not-to-use, but the singular 'one native' focus makes the intended usage unambiguous.

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=true, so the description does not need to repeat safety behavior. It adds useful context about what kind of information is returned (CDN cache, embedded snapshot, newest published build, package version). However, it does not disclose output format, potential staleness, or whether the values are computed live, which would add extra transparency beyond the annotations.

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

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

The description is a single compact sentence that lists the key output areas without filler. Every clause adds information about what the tool reports, and the structure is easy to parse quickly.

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-parameter, read-only informational tool, the description covers the main content areas an agent needs to set expectations. There is no output schema, but the listed items provide a reasonable sketch of the response. It could be slightly more complete by explicitly stating that it returns this information, but the overall context is sufficient for a simple call.

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 for parameter semantics is 4. The description instead clarifies the meaning of the tool's output by listing the fields of build data it exposes, which is helpful given there is no output 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 clearly identifies the resource as build information and enumerates its contents: index build, provenance, newest published build, and package version. It lacks an explicit verb like 'returns' or 'retrieves', but the title 'Which build this server answers for' and the noun-phrase description make the purpose understandable. It does not explicitly distinguish itself from siblings like server_status, though its content focus is distinct.

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 guidance is given about when to call this tool versus alternatives such as open77_server_status or open77_changes. The zero-parameter signature implies a simple read-only lookup, but the description never states the intended use case or conditions for selection.

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 description discloses that results are derived from the `since` field and limited to added natives, which is behavior beyond the readOnlyHint annotation. It doesn't describe the output layout or edge cases, but annotations already cover the safety profile, so the added detail is meaningful.

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 core operation and immediately followed by relatable user questions. There is no filler and no repetition of schema content.

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 read-only two-parameter diff tool, the description plus schema and annotations are sufficient: it states what is returned (added natives), how the comparison works, and when it is useful. No missing information is needed to select or invoke the tool 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 coverage is 100%: `from` and `to` are documented with examples and the `main` sentinel default. The description only restates the direction of comparison and adds no parameter detail beyond what the schema already provides.

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 first sentence states a precise operation: list natives a newer build adds relative to an older build, using the `since` field. This is more specific than the title and distinguishes it from sibling search/browse tools by its build-comparison scope.

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 gives concrete when-to-use scenarios ('what do I gain by updating', 'why does this work on my dev box and not on the owner's server'), making the trigger conditions clear. It does not name alternative tools or when-not-to-use conditions, so it stops short of a 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?

It discloses that commands run with operator authority and that output behavior varies: normal output returns inline, while resource-claimed commands reply in the log a tick later. This adds practical context beyond the annotations, which already mark the tool as destructive and non-idempotent.

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 deliver the core behavior, examples, and output timing with no filler. The most important information is front-loaded, and every clause adds value.

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 one-parameter tool with no output schema, the description is complete: it states what happens, under what authority, with example inputs, and how output will be delivered. The annotations additionally cover the destructive and non-idempotent nature, so nothing essential is 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 coverage for the single `command` parameter is 0%, so the description must carry the meaning; it does by explaining that the value is one console line and by providing concrete command examples. It does not fully define all possible command syntaxes, but that is impractical and the examples are sufficient for a single free-text parameter.

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 ('Runs') and a clear resource ('one line at the server console'), with concrete examples like `resources` and `ensure my_res`. It clearly differentiates this command-execution tool from siblings such as `open77_console_tail` and `open77_server_status`.

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 establishes the context: execute one line of console input with operator authority, and it gives representative commands. It does not explicitly list alternatives or when not to use it, but the one-shot, inline-output behavior makes the intended use clear.

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 mark the tool read-only, and the description adds useful behavioral context: logs are recent, errors carry the resource in brackets, and filtering is optional. This goes beyond what the readOnlyHint alone provides.

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 first sentence states what the tool returns and its filters; the second provides usage timing and a behavioral hint about errors.

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 read-only log tail tool with fully documented optional parameters, this is reasonably complete: it covers purpose, timing, filtering, and error formatting. It does not describe the exact return structure, but that is less critical given the simple log-line nature and the read-only annotation.

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 all four parameters are already documented with clear descriptions. The description restates the regex and resource filters but adds no new parameter-specific meaning 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?

The description clearly states the tool retrieves recent server log entries and can be filtered by regex or resource name. It is easy to understand as a read-only tail operation, though it does not explicitly differentiate from sibling tools like console_command or server_status.

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 gives a concrete usage context: 'Use after a reload to read what the server said.' It also mentions optional filtering, which helps an agent decide when this tool is appropriate, though it does not state exclusions or name 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=true, and the description does not contradict this. It adds valuable behavioral context beyond the annotation: it explains that the tool returns 'the fields the server itself answers Open77.data.* from,' clarifies that animation inventories are discovery data (not playback), and notes the '_player' suffix convention for spawnable vehicles. This enriches the agent's understanding of what the tool does and its constraints, though it does not cover all potential behaviors like pagination (handled in 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?

The description is concise at roughly four sentences, front-loading the purpose ('Look up game-data names') and then adding necessary detail. It has no fluff or redundancy—the parenthetical list of catalogues is useful even though it duplicates the schema, and the vehicle suffix insight is valuable. It could be slightly tighter, but it 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 read-only catalogue lookup tool with 4 parameters and no output schema, the description covers the essential usage: purpose, catalogue enumeration, query behavior, return nature, and a naming nuance for vehicles. Pagination and limits are already in the schema, so the description doesn't need to repeat them. It is complete enough for an agent to call this tool correctly, though it does not explicitly state that the 'catalogue' parameter is required (the schema does).

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?

Since schema description coverage is 100%, the baseline is 3. The description adds meaning beyond the schema by explaining that 'query matches the record/path/name' (schema just says 'Substring or words to match'), and it gives the '_player' suffix convention for vehicles, which is not in the schema. It also lists the catalogue values in the description, reinforcing but not contradicting the schema's enum description.

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

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

The description clearly states a specific verb+resource: 'Look up game-data names,' and enumerates the exact catalogues available (vehicles, weapons, items, etc.). It also distinguishes itself from playback by noting 'animation inventories are discovery data, not playback allowlists,' which clarifies its role. This is specific enough to separate it from sibling tools like open77_search without opening the schema.

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 usage (for looking up game-data names) and provides a useful caveat about animation inventories being discovery data, but it does not explicitly mention alternatives or when not to use this tool. No sibling tools are referenced for contrast, leaving the agent to infer that this is the tool for catalogue lookups without exclusion guidance.

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

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

The readOnlyHint annotation already establishes safety, and the description adds meaningful behavioral detail: returned events include sides, documented payloads, and guides; unprefixed host lifecycle and bus events are included; reserved prefixes are listed. This goes well beyond the annotation without contradicting it.

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 compact and front-loaded: it states the core behavior first, then provides useful examples and the special lifecycle value. Every sentence adds value, and the reserved-prefix note is a useful extra without bloat.

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 scope, prefix values, lifecycle filtering, and output contents, but the documentedOnly parameter remains unexplained and there is no output schema to clarify the return shape. For a simple read-only listing tool this is mostly sufficient, but one parameter is still underspecified.

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 prefix parameter is well enriched with examples and the special 'lifecycle' value, but documentedOnly has no schema description and the description does not explicitly define what it filters. With 50% schema coverage, the description compensates for prefix but leaves documentedOnly ambiguous.

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 ('List') and resource ('events'), then clarifies the scope: by prefix, all events, lifecycle-only, and reserved prefixes. It clearly distinguishes this tool from siblings by focusing on event enumeration rather than searching, building, or resource management.

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 gives concrete usage context: pass a prefix like open77:map or open77:chat, or pass prefix=lifecycle for host lifecycle events. It does not explicitly name alternatives or say when not to use the tool, but the usage context is clear enough for correct selection.

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=true, so the safety profile is clear. The description adds useful behavioral detail: it falls back to a search when the name is not in the alias table and explicitly surfaces deliberately absent mappings. This goes beyond the annotations without contradicting them.

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 with no filler. The core purpose is front-loaded, and the second sentence adds the fallback behavior efficiently. Every word 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 read-only lookup with one parameter, the description covers purpose and fallback behavior. But with no output schema, it does not explicitly describe the return shape (e.g., a string, an absence marker, or search results) and lacks formatting details for 'name'. These gaps mean an agent might not know exactly what to expect or how to format input.

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 one required 'name' parameter with no description (0% coverage). The description compensates partially by identifying that 'name' refers to a FiveM native or Citizen call, giving the parameter meaning. However, it does not specify expected format, case sensitivity, or how the fallback search affects the input, so compensation is incomplete.

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 that the tool reveals what Open77 uses in place of a FiveM native or Citizen call and what is deliberately absent. This communicates a clear mapping/lookup purpose and, combined with the title, distinguishes it from sibling tools. It lacks an explicit imperative verb like 'returns' or 'maps,' but the meaning is specific enough.

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 the tool should be used when you have a FiveM native or Citizen call name and need its Open77 equivalent. It also mentions fallback search behavior, but it does not explicitly state when to choose this tool over alternatives like open77_search or open77_api, nor does it provide 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?

Beyond the readOnlyHint annotation, it discloses the output format (Markdown) and the behavior of omitting slug (returns a list). These are useful behavioral details not present in the schema or annotations.

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, efficient sentence that front-loads the core purpose and immediately provides actionable usage guidance. 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?

Given the tool's simplicity (2 optional params, no output schema), the description covers the main use cases: reading a specific guide/section and listing guides. It could mention error handling, but that is not essential for a read-only tool with annotations clarifying safety.

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 covers both parameters at 100% with descriptions. The description adds context on how to obtain valid slugs (from open77_search) but does not enrich the meaning of the parameters themselves 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 (read) and resource (guide/section), and outputs as Markdown. It also names the slug source (open77_search) which differentiates it from sibling search tools. Purpose is unambiguous.

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?

Provides clear context: slugs come from open77_search or from the list returned when slug is omitted. This tells an agent exactly when and how to call the tool, though it does not explicitly name alternatives to avoid using instead.

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=true, so the description does not need to establish safety. The description adds useful scope detail about what documentation is returned, but does not disclose output format, size, or any other behavioral characteristics. This is acceptable but minimal.

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

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

A single sentence that front-loads the key scope and enumerates the deliverable components. There is no filler or redundant information; every phrase adds value.

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-parameter, read-only reference tool with an empty schema, the description tells the agent what it will receive: every directive with form, default, rule, and an example. It lacks an explicit statement of the output representation and any usage context, preventing a perfect score.

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 is 4. The description compensates by explaining what the returned content covers, and no parameter-level detail is required.

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

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

The description clearly identifies a reference/documentation tool for the open77.lua resource manifest grammar and lists the content components (form, default, rule, example). It is specific enough to be distinguished from sibling tools by topic, though it does not explicitly contrast with open77_server_config_schema.

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 guidance is given about when to use this tool versus sibling reference tools like open77_guide, open77_api, or open77_server_config_schema. There are no exclusions or context hints, so an agent must infer the intended use from the title and description alone.

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=true, so the agent knows this is a safe read operation. The description adds useful context about the output format (one line per native with permissions and since) and the special case for globals. However, it doesn't disclose details like pagination, sorting, or whether the output is truncated for large namespaces. With annotations covering the safety profile, a 3 is appropriate.

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 zero waste. The core behavior is front-loaded, the output format is specified, and the special case is stated concisely. Every word 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 read-only list tool with no output schema, the description covers the main behavior and the namespace parameter. However, the runtime parameter is completely unexplained, and there's no mention of what the output looks like beyond 'one line each' (e.g., whether it's a table, JSON, or plain text). The tool is simple enough that this is adequate but not complete.

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

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

Schema description coverage is 0%, so the description must compensate. It explains the 'namespace' parameter semantics well (including the omit-to-list-namespaces behavior and _G for globals), but it doesn't explain the 'runtime' parameter at all. The runtime parameter has an enum (client/server) but its meaning and whether it's required are left to inference. The description partially compensates but leaves a gap.

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 ('List') and resource ('a namespace'), and clarifies the output format ('one line each with permissions and since'). It also explains the special case of omitting the namespace to list namespaces. However, it doesn't explicitly distinguish itself from sibling tools like open77_resources or open77_search, though the namespace-specific scope is clear.

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

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

The description implies when to use it: when you need to enumerate natives under a namespace or list namespaces. It gives examples of valid namespaces (Open77.vehicles, Open77.players, _G) and the special behavior for globals. However, it doesn't explicitly state when NOT to use it or mention alternatives like open77_search for finding specific natives.

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 all annotations false, the description carries the burden and does add value: it states writes happen under the resources root or `directory` and that existing resources are never overwritten. This is meaningful safety-relevant behavior beyond the annotations, though it omits auth and return details.

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 focused sentences with the primary action front-loaded, followed by supported kinds and a key safety guarantee. No filler or redundancy.

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

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

For a scaffolding tool with no output schema, the description covers what is generated, which kinds are supported, where output goes, and overwrite behavior. It does not describe the return value or required permissions, but those are secondary for this kind of creator 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 75%, and the description complements it by explaining that kind determines whether a WebUI page or export guard is generated and that `directory` overrides the default root. It does not add much about `name` or `summary`, but the schema already documents those.

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 ('Creates') and resource ('a resource'), and enumerates concrete generated artifacts (manifest, lifecycle handlers, WebUI page or export ownership guard). This clearly distinguishes it from read/search siblings like open77_resource or open77_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?

Clearly implies use when scaffolding a new resource and lists the supported kinds. It does not explicitly name alternatives or exclusions, but the no-overwrite guarantee and directory scoping give enough contextual 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?

Annotations already signal a safe read-only operation, and the description adds useful behavioral context by describing the kind of data returned (permission gating, native references, guide declarations). It does not contradict the annotations and gives the agent a preview of output semantics.

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 core behavior is front-loaded, and the clarification about manifest permission strings is immediately useful. Every phrase 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 tool with one optional read-only parameter, the description is mostly complete: it states what the tool returns and the general input/output relationship. There is no output schema, so a bit more detail about response shape could help, but the behavior is simple enough that an agent can likely call it correctly.

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

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

The schema provides no description for the 'name' parameter (0% coverage), so the description must carry meaning. It partially does by implying that a named permission returns details and an omitted name returns the whole list. However, it never explicitly states that 'name' is the permission name or that omitting it yields the full list, leaving some inference required.

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

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

The description states a clear resource type ('manifest permissions') and what the tool returns: either a single permission with details on what it gates, which natives, and which guides declare it, or the whole list. It does not explicitly contrast itself against sibling tools, but the purpose is specific enough to be understood.

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 explicit guidance about when to use this tool versus alternatives like open77_manifest_schema or open77_guide. The phrase 'or the whole list' implies the optional name selects one item vs. all items, but this is not stated as a decision rule. No exclusions or alternative suggestions are provided.

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 non-read-only, non-destructive, and idempotent. The description adds valuable behavioral detail: reload republishes an edited resource to the running session, and validate runs the server's parser and Lua compiler without executing files. It also hints at the workflow (check log after). This goes beyond annotations, though it doesn't detail behaviors for start/stop/restart or error scenarios.

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 with zero fluff. The first sentence states the core purpose, the second adds key action details and a follow-up step. Information is front-loaded and every sentence earns its place, making it highly concise and well-structured.

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 tool with no output schema, the description covers the essential aspects: what it does, which actions have special meaning, and how to observe results (via log tail). It doesn't mention prerequisites or return values, but given the simplicity and the enum-driven action parameter, the description is sufficiently complete for an agent to call it correctly.

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

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

Schema coverage is 0%, so the description must explain parameters. It implicitly indicates that 'name' refers to the resource and 'action' specifies the operation, and it explicitly elaborates on the actions reload and validate. However, it doesn't explicitly define start/stop/restart semantics or clarify that 'name' is the resource name, leaving some ambiguity. The description partially compensates for the lack of schema coverage but not fully.

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 clearly states the tool's purpose: 'Runs one resource action on the live server through Warden.' It specifies the verb (run), the object (resource action), and the context (live server, Warden). It further differentiates actions like reload and validate, and explicitly references the sibling tool open77_console_tail for reading logs, making its purpose distinct from other 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?

The description provides clear context: it is used for resource actions on the live server, with reload as the typical step after an edit and validate for checking without running. It also instructs to read the log afterwards via open77_console_tail. However, it doesn't explicitly state when to use this tool over alternatives like open77_validate or provide exclusions, leaving some 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?

Annotations already declare readOnlyHint=true, so the description is not responsible for safety signaling. It adds modest context by naming Warden as the source and emphasizing the 'running server' and 'discovered' scope, which implies current runtime state rather than persisted configuration.

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 that conveys the essential meaning without filler. Every word contributes: resource scope, state, and Warden as the reporting source.

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-parameter, read-only list operation, the description is largely complete: it states what is returned and the source. It could be slightly stronger by explicitly noting it returns all discovered resources or how this relates to open77_resource, but nothing needed to invoke the tool correctly is 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?

The tool has zero parameters, so the schema imposes no burden. Baseline for no parameters is 4, and the description does not need to explain parameter meaning; it correctly focuses on the returned concept.

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 clearly identifies the resource: resources discovered by the running server, with their state, sourced from Warden. It conveys what the tool provides, though it lacks an explicit verb like 'List' or 'Get'. It also hints at differentiation from siblings like open77_resource (singular) by focusing on the live server's discovered set.

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 guidance is given on when to use this tool versus alternatives. There is no mention of when to prefer this over open77_resource, open77_server_status, or open77_changes, and no exclusions or prerequisites 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?

Annotations already declare readOnlyHint=true, and the description adds valuable behavioral context beyond that: it returns the build it answers for, and it explains that a query containing 'server' or 'client' automatically applies that filter. No contradictions with annotations.

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 efficiently structured: purpose stated first, then usage guidance, then a behavioral note. No wasted words, and it front-loads the key information an agent needs to decide whether to call this 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?

For a search tool with no output schema, the description covers the essential aspects: what it searches, when to use it, how to refine with runtime, and what it returns (the build). It doesn't detail the result format, but given that full-text tools are available for details, this is sufficient.

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 75% (3 of 4 params have descriptions). The description adds meaning beyond the schema by explaining the significance of the runtime parameter and the dual-contract issue for names like RegisterCommand, plus the auto-filtering behavior of the query. This is more than the baseline for high schema coverage.

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 clearly identifies the tool as a lexical search over multiple Open77 resource types (natives, guides, events, permissions, FiveM equivalents) and explicitly differentiates it from the full-text tools open77_api/open77_guide by instructing to use it first.

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 explicit guidance: 'Use it first; then open77_api / open77_guide for the full text' and explains when to pass the runtime parameter with concrete examples of names that have different contracts per runtime. It also notes that the query itself can auto-apply the server/client filter, making usage conditions clear.

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, so the read-only nature is covered. The description adds that the tool exposes the schema used by the dedicated server and that the key filters to a section, which is useful context. It does not cover behavior when no key is provided, but this is a minor gap given the simple read-only nature.

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

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

The description is a single, efficient sentence with no wasted words. It front-loads the core purpose and then adds the parameter usage in the same sentence. Slightly more structure could separate the full-schema behavior from the filtered behavior, but it remains concise and readable.

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 one-parameter read-only schema tool, the description covers the main purpose and key filtering. However, with no output schema and no mention of the behavior when key is omitted, an agent may not know whether calling without a key returns the full schema or errors. This ambiguity prevents a higher completeness score.

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 provides only a bare 'key' string with 0% description coverage, so the description carries the burden. It clarifies that key should be a top-level configuration section such as network, resources, warden, or voice, and that it filters the schema to that section. It does not state what happens if key is omitted, but the core semantics are well conveyed.

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 clearly identifies the tool as providing the JSON schema used to validate server.jsonc, which distinguishes it from siblings like open77_manifest_schema. However, it lacks an explicit verb such as 'returns' or 'retrieves', relying on the noun phrase 'The JSON schema' to convey the action.

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 how to use the tool ('Pass a top-level key... for that section only') but gives no guidance on when to choose this tool over alternatives, such as open77_manifest_schema or open77_validate. Usage is implied rather than explicitly contrasted with sibling tools.

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=true, so the description does not need to repeat that. It adds value by revealing an authentication requirement (Warden session) and enumerating the exact data points returned (build, uptime, players, resources, load). No contradiction with annotations; it complements them.

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. The first packs the purpose and content list, the second states the prerequisite. No filler, front-loaded with the key scope ('Warden's dashboard for the server next to this session').

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-parameter, read-only status tool, the description is sufficient: it explains the tool's output scope (build, uptime, players, resources, load), the prerequisite (session), and the operational context (next to this session). It does not describe return formatting, but that is not essential given the tool's simplicity and the absence of an output schema.

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?

There are no parameters (schema has empty properties), so the description correctly does not need to elaborate on them. The schema coverage is trivially 100%, and the baseline for zero-parameter tools is 4. The description adds no parameter-specific context, but none 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?

The description clearly states what it does: a dashboard for the server next to the session, listing content (build, uptime, players, resources, load). This differentiates it from siblings like open77_console_tail or open77_resources. It is not a tautology and conveys a specific resource and its scope.

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 mentions a prerequisite ('Needs a Warden session') but does not explicitly say when to use this tool versus alternative status or monitoring tools (e.g., open77_resources, open77_console_tail). The 'server next to this session' phrasing gives some contextual scoping but no direct comparison or exclusion.

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?

Beyond the annotations, the description discloses that a set is applied live only when the resource accepts it and that the server reports whether the change is pending a restart. This adds meaningful operational context and does not contradict the readOnlyHint, idempotentHint, or destructiveHint annotations.

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 only two sentences long, front-loads the read/set mode, and includes the important restart-pending behavior without filler. Every sentence contributes useful information.

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 mode selection and set response behavior, but it leaves the read response format unclear and does not fully explain what 'every resource declared' means. Since there is no output schema, the description should do more to define what a successful read returns.

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 documents only the value parameter, and the description clarifies that providing a value triggers a set while omitting it triggers a read. However, the resource and key parameters are still semantically vague, with no explanation of valid key formats or how resource identifies the target.

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 clearly identifies the action as reading live tunables or setting one via 'resource + key + value'. It distinguishes itself as a tunables-specific tool, though 'every resource declared' is somewhat awkward and the read output is not defined.

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 the main usage pattern: omit value to read, provide resource/key/value to set. It does not explicitly state when to use this tool instead of siblings like open77_resources or open77_server_config_schema, nor does it provide when-not-to-use 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?

Beyond the readOnlyHint annotation, it discloses important behaviors: the Lua parser version caveat ('5.3-compatible parser; exact 5.4 via the server's --lint when present'), command-name collisions being only warnings for literal RegisterCommand names, and the warning-only nature of that check. This gives an agent realistic expectations about strictness and side effects.

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

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

The description is dense yet front-loaded with the core operation and then efficiently organizes the many check categories. Every clause contributes useful information, with no filler or repetition.

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?

Given the tool's single required parameter and no output schema, the description covers what is validated, the input source, the build context, and important edge cases like Lua version and literal command names. An agent has what it needs to call the tool appropriately.

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 already covers the parameter fully, but the description adds meaningful context by saying the resource can come 'from open77_workspace or an absolute path', clarifying where acceptable names come from beyond the schema's wording.

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

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

The description names the exact operation ('Static checks of one resource directory against the served build') and enumerates the specific check categories, making the purpose unmistakable. This clearly separates it from siblings such as open77_build or open77_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 gives clear context for when validation applies, especially 'against the served build' and the detailed list of checks. It does not explicitly name alternative tools or state when not to use it, but the intended scenario is strongly 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?

Beyond the annotations, it discloses strict validation behavior ('Warden refuses anything else'), the necessity of exact sha256 matching, and the return value (job id). This gives the agent the behavioral context needed to invoke and monitor the operation correctly.

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?

Four short sentences, each adding a distinct piece of information: purpose, prerequisites, return value/next step, and a safety constraint. Nothing is wasted and the key action is front-loaded.

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?

Given no output schema, the description still tells the agent what to expect (job id) and how to proceed. It also covers the essential safety and validation constraints, making the tool usable without further lookups.

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 only 33%, but the description adds meaning for sha256 (must exactly match what open77_workshop_plan returned) and consent (human's explicit yes). planId is not elaborated, but its role as the identifier is reasonably inferable from the schema and name.

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

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

The description clearly states the action ('Installs a plan'), identifies the resource, and sets the precondition that the human has read and accepted it. It also names the related plan and job tools, which differentiates it from the sibling install/plan/release flow.

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?

Explicitly states when it is safe to call ('Never call this without the human's explicit yes'), what inputs are required (consent=true and exact sha256), and what to do next ('follow it with open77_workshop_job'). This is strong practical guidance for an 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?

Beyond the readOnlyHint and openWorldHint annotations, it discloses a meaningful terminal condition ('done when it reports committed') and the dual-mode behavior. It does not contradict the annotations and adds useful behavioral context, though it doesn't cover failure handling or response shape.

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

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

The description is a single sentence with no filler. The primary action is front-loaded, and the alternative mode is clearly introduced by 'or' with the conditional 'when no id is given.'

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 dual-mode behavior, the optionality of jobId, and the job completion condition are all described, while the readOnly/openWorld annotations cover the safety profile. The main gap is the absence of response-shape details, especially since there is no output schema, but the title and 'lists the packages' provide enough orientation for invocation.

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 a single optional jobId with no description (0% coverage). The description compensates by explaining the parameter's presence/absence semantics: with an id it follows the job, without one it lists installed packages. This is exactly the meaning missing from 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?

The description states two specific behaviors: 'Follows an installation job by id' and 'lists the packages installed through the Workshop when no id is given.' This clearly distinguishes it from related siblings like open77_workshop_install and open77_workshop_status.

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 gives explicit context for when to use each mode: provide an id to follow a job, omit it to list installed packages. It doesn't explicitly name alternative tools or exclusions, so it stops short of full 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?

Annotations already indicate this is not read-only qualified, and the description adds meaningful behavioral detail: Warden inspects the package nodes, lists permissions/dependencies/blockers, and the returned plan's sha256 is a prerequisite for installation consent. It does not mention the discard operation exposed via the schema, which is a minor transparency 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?

Two terse sentences plus a clear human-facing directive. The core behavior is front-loaded, and the sha256/consent instruction is concise but actionable. No filler or redundant restatement of the schema.

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 main create/read workflow competently enough, but there is no output schema and the return value is only partially described via sha256 and the Warden listing. The discard behavior and advanced acknowledgment/prerelease parameters are absent from the narrative, making the description less complete than the tool's complexity warrants.

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 only 43%, so the tool description needs to compensate. It clarifies that releaseId/projectId relate to an installation plan for a release and that planId is used for reading an existing plan, but it leaves allowPrerelease and the two acknowledged arrays to name inference and does not mention the discard flag at all.

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 clearly identifies two concrete operations — 'creates an installation plan for one release' and 'reads an existing plan by id' — and names the resource explicitly. It also enumerates what the plan contains, which distinguishes it from sibling tools like open77_workshop_install or open77_workshop_status.

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 embeds practical usage guidance: generate a plan, show it to the human, obtain consent, and use the plan's sha256 with open77_workshop_install. It does not explicitly state when not to use this tool or which alternative to prefer, but the reference to the install sibling provides enough routing context.

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=true and openWorldHint=true, covering the safety and scope posture. The description adds that the result covers all releases and includes state, files, tested builds, and dependencies. It does not disclose ordering, pagination, or representation of 'files'/'builds', so it adds useful context but not deep behavioral detail.

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

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

The description is a single sentence with no filler; the first clause front-loads the resource and contents, and the second clause adds a purpose. It could be slightly clearer with an explicit verb, but it is appropriately sized.

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 one-parameter, read-only listing tool, the description covers the main output contents and the practical purpose (release id for plans). It omits explicit parameter guidance and any mention of response shape beyond the listed fields, and does not distinguish itself from sibling workshop tools. Given the simple complexity and annotation coverage, it is minimally complete.

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

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

The schema has one required parameter, projectId, with 0% description coverage, so the description must compensate. It only says 'of a project,' which trivially maps to projectId and adds no format, source, or usage detail beyond the schema's type/format. This is insufficient compensation for the low schema coverage.

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

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

The description names the resource ('releases of a project') and scope ('Every release'), and lists included contents ('state, files, tested builds and declared dependencies'). The verb is implicit rather than explicit ('list'/'get'), but the readOnlyHint annotation makes the operation clear. It does not explicitly contrast with siblings like open77_workshop_search, so differentiation is only partial.

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 'the release id is what a plan needs' implies a concrete use case: call this when release IDs are needed for planning. There is no explicit when-to-use, when-not-to-use, or alternative tool mention, so the agent must infer context from sibling names. This is implied guidance, not strong 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?

The annotations already declare readOnlyHint=true and openWorldHint=true, so the safe read-only nature is covered. The description adds useful context about Warden-mediated access and the two input modes, but does not disclose return shape, pagination, or other runtime behavior beyond what annotations and schema already imply.

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

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

The description is a single sentence that front-loads the action and resource, then adds the link-resolution mode without wasted words. It is appropriately compact and scannable.

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

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

The tool has five optional parameters, a cursor for pagination, and no output schema, yet the description only covers browsing and link resolution. It does not explain sort/cursor usage or pagination behavior, leaving an agent to guess at how to page through results. The annotations and schema partially mitigate this, but gaps remain.

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 only 60%, and the description compensates by spelling out accepted link formats and the workshop categories that map to the category parameter. It adds meaning beyond the schema, though query and cursor remain unclear from both sources.

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

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

The description names a specific operation—browse/search or link resolution—against a concrete resource (the OPEN//77 Workshop) and lists content categories. It doesn't explicitly differentiate from sibling tools like open77_workshop_install or open77_workshop_status, but its purpose is clear and unambiguous.

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

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

The description provides clear contexts for use: browsing the workshop or resolving a pasted link, including two accepted link formats. It does not mention when not to use the tool or name alternatives, but the usage guidance is direct and sufficient for a search/resolve 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 this as read-only and open-world-safe, and the description does not contradict them. It adds useful context by naming the underlying settings that determine availability (masterServer and warden.hubFileGatewayOrigin), but it does not disclose the exact return shape or any other behavioral details.

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

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

The description is a single well-formed sentence that states scope and relevant configuration context without wasted words. The key capability question is front-loaded.

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-parameter, read-only status check, the description is mostly complete: it tells the agent what question the tool answers and what settings influence it. It does not describe the return value format, but the phrasing 'Whether...' strongly implies a boolean-like capability answer, which is adequate given the low complexity.

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 and 100% schema description coverage, so there is no parameter meaning for the description to add. The described behavior is sufficient for this parameterless tool.

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 clearly states the tool reports whether Workshop-related operations are available, naming the specific capabilities (browse, install, publish) and relevant configuration settings. It is distinct from action-oriented sibling tools like workshop_install or workshop_search because it is a status probe, though it does not explicitly name an alternative.

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 wording 'Whether this server can...' implies this should be used as a capability/precondition check before attempting Workshop operations. However, there is no explicit guidance about when to prefer this over the sibling status or Workshop action tools, nor any stated exclusions.

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

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

Annotations already mark it read-only; the description adds useful behavioral detail by listing what is detected (server location, build, config, resources root, resources) and by noting that it re-detects on every call, implying fresh state rather than a cached result. It does not cover return formatting or failure modes, but those are secondary for a read-only 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?

The description is compact and contains no filler, with the key output scope listed ahead of the 're-detects' behavior. The phrasing is slightly awkward as a sentence fragment, but it remains efficient and scannable.

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 no-required-args read-only detection tool, the description lists the main return content and refresh behavior, which is largely sufficient. It is incomplete in not differentiating from sibling resource/status tools or noting the response shape/error conditions, but these are not severe gaps given the low complexity.

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 covers both optional parameters with descriptions (config override and serverDir override), so the description does not need to repeat parameter-level details. It adds no extra semantic nuance beyond the schema, keeping this at the baseline for full schema coverage.

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 clearly identifies a read-only detection operation: it reports where the Open77 server for the current session is located, plus its build, config, resources root, and contained resources. The verb is only implicit ('re-detects'), and it does not contrast with siblings like open77_resources or open77_server_status, so it stops short of full sibling differentiation.

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 provides clear context that this is the tool to call when you need the detected server's location and configuration, including the fact that it is bound to 'this session'. It does not state when to prefer an alternative such as open77_server_status or open77_resources, so there are no explicit exclusions.

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