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

With no annotations, the description carries the full transparency burden. It implies a read-only lookup and details the returned fields, but it does not mention failure modes, permissions, or confirmation that no side effects occur. For a get-type tool this is acceptable but not comprehensive.

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 purpose and immediately followed by the intended use case. No filler words 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?

The output schema exists, so return structure is well-covered. The description clarifies the tool scope, content, and a key use-case, which is sufficient for a simple single-parameter getter. It does not address error cases, but that is a minor omission for such a routine read operation.

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 only hints that agent_id identifies the target through 'one agent,' but does not explain how to obtain an agent_id, its uniqueness, or any value constraints. The schema only provides the type string, leaving the parameter mostly unexplained.

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

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

States a specific retrieval operation for one agent, enumerating the returned content (class, device/host, manifest hash, heartbeat/status). It clearly distinguishes itself from sibling tools like efm_list_agents (plural) and efm_get_agent_class (only class) by its scope and content.

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 a concrete use: to confirm which manifest an agent actually reports. It does not explicitly mention alternatives or when not to use, so it misses the full when-not guidance required for a 5, but the context is 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?

With no annotations, the description carries the full burden. Its language ('Detail', 'resolve') signals a read-only retrieval, and it lists observable outputs, but it does not explicitly state that it has no side effects, whether any permissions are needed, or what it returns in error/edge cases. That makes it serviceable but not fully transparent.

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 brief and front-loaded, leading with the resource and key result fields. The ancestry 'Start here to resolve a class to its manifest' is a helpful single-sentence directive with no wasted prose.

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 get tool with an output schema, the description provides enough working context: the tool targets a single agent class, shows manifest/monitoring/flow details, and is described as the starting point for manifest resolution. The main gap is the agent_class value semantics, but that is mitigated by its simple single-parameter shape.

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 coverage is 0%, so the description should compensate, but it only says 'one agent class' without explaining how to form or source the agent_class string. The agent can infer it is an identifier or class name, but the definition adds almost no value beyond the schema's own parameter 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 states a specific verb-plus-resource ('Detail for one agent class') and enumerates the returned areas: manifest ids, monitoring config, and Designer flow association. It does not explicitly compare itself to a sibling like efm_get_class_monitor or efm_get_manifest, but the resource scope is clear enough to establish a distinct purpose.

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 'Start here to resolve a class to its manifest' gives a clear workflow directive and tells the agent when this tool is the entry point. It does not name sibling alternatives or state when to choose them instead, but it offers a clear use case without 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?

With no annotations provided, the description carries the burden of behavioral disclosure. It discloses that the tool returns current flow version, agent counts (online/missing), health status, and connection metrics, which is useful. However, it doesn't disclose whether this is a read-only operation, whether it aggregates data from multiple sources, or any latency/caching behavior.

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

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

The description is compact and front-loaded with the resource and key metrics. The parenthetical question at the end adds useful context without bloat. It earns its place, though the formatting with line breaks is slightly unusual.

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

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

The output schema exists, so return values are covered. However, with no annotations and 0% parameter coverage, the description should provide more guidance on the required agent_class parameter and how it relates to sibling tools. The core purpose is clear, but an agent might not know how to obtain a valid agent_class value.

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

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

Schema description coverage is 0%, so the description must compensate for the undocumented 'agent_class' parameter. The description mentions 'per-class' and 'agent class' context, but doesn't explicitly explain what values agent_class accepts or how to find valid class names (e.g., via efm_list_agent_classes). This is 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 ('get') and resource ('class monitor view'), and clarifies the core question it answers ('is this class healthy and how many agents are up?'). It distinguishes itself from sibling tools like efm_get_agent_class by focusing on health/connection metrics rather than class configuration, though it doesn't explicitly name a sibling.

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 checking class health and agent counts, which is a clear context. However, it doesn't explicitly state when not to use it or mention alternatives like efm_get_agent_class or efm_list_agents for more detailed agent-level information.

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

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

With no annotations, the description carries the behavioral burden. It discloses that the result is the full live document, positions it as ground truth, and implies a read-only fetch. It does not overstate side effects or obscure the output nature beyond the provided 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 compact and front-loaded, naming the exact resource (full live Designer flow document), its contents, and the intended use case in two sentences with no filler.

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

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

With a single obvious parameter and an output schema available, the description covers the key context: the document is authoritative, current, and should be read before reasoning about a flow. It could mention how to obtain a flowId, but the tool name and schema make this largely unnecessary.

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 0% description coverage and the description only mentions 'flowId' without adding format, provenance, or relationship to other IDs. The parameter name is self-explanatory for flow ID, and the structure is simple, but the description fails to compensate fully for the bare 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 tool as retrieving the full live Designer flow document for a flowIdKN and enumerates the contained elements (process groups, processors, connections, controller services, parameters). This distinguishes it from sibling tools like efm_list_flows or efm_validate_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?

It gives explicit guidance to read this before reasoning about a flow, establishing when the tool should be invoked. It does not explicitly name sibling alternatives or say when not to use it, but the context is clear enough 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?

With no annotations provided, the description must carry the full behavioral burden. It states what is returned (manifest components) and its informational purpose, but does not explicitly confirm read-only behavior, error conditions, or required permissions. The word 'get' implies a read operation, but that is not guaranteed. The description provides some transparency but leaves gaps.

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

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

The description is two sentences, front-loaded with the core purpose, and adds a high-value explanatory sentence about deployability. There is zero redundancy or filler; 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?

Given an output schema exists (as noted in context), the description need not detail return values. It covers the primary purpose, the scope, and the practical implication for flow building. It does not mention edge cases like missing classes or pluralization of manifests, but for a simple retrieval tool this is acceptable. Overall, it is sufficiently complete for an agent to decide and call correctly.

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

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

Schema description coverage is 0%, so the description must compensate. It references 'for a class' which clarifies that agent_class is the class identifier, and the purpose sentence links it to deployability. However, it does not specify the format of agent_class, where to find valid values (e.g., via efm_list_agent_classes), or any constraints. This is adequate but not thorough.

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 agent manifest(s) for a class, enumerating the manifest components (processor, controller-service, reporting-task types) and its role in determining deployability. It distinguishes from sibling efm_get_manifest_by_id by focusing on 'class' rather than an ID, though it does not explicitly name the 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 description gives a purpose-driven usage hint ('tells you whether a flow you want to build is even deployable to that class's agents'), which implies when to use it. However, it does not explicitly contrast with efm_get_manifest_by_id or other sibling tools, nor does it state prerequisites like obtaining a valid agent_class from efm_list_agent_classes.

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

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

No annotations are provided, so the description carries the full burden. It discloses the return content ('full component-type catalog with property descriptors'), which is a useful behavioral trait. However, it does not mention any side effects, permissions, error behavior, or whether the operation is read-only. For a simple read-by-id tool, this is adequate but not rich, so 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?

The description is two sentences, front-loaded with the primary action and outcome. Every clause serves a purpose, with no filler or redundancy. The structure is 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?

Given the tool's simplicity (one parameter, output schema provided), the description covers the essential aspects: what the tool does, where the ID comes from, and what it returns. It does not explain differences from efm_get_manifest or address edge cases, but for a straightforward lookup, it is nearly 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. The only parameter, manifest_id, is not elaborated beyond the schema property name. The description merely says 'by its id', adding no format, examples, or source details beyond what the schema already implies. This is a minimal compensation for the lack of schema descriptions.

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 verb (get) and resource (one agent manifest by its id), and specifies the source of the id ('as listed on an agent class or agent record'). It is distinct from siblings like efm_list_agent_classes and efm_get_agent, but does not explicitly differentiate from the closely named efm_get_manifest, so it lacks explicit 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?

The description implies when to use it by indicating the id comes from an agent class or agent record, providing clear context. It does not explicitly state when not to use it or name alternatives, but the context is enough for an agent to infer that this tool is for fetching a specific manifest by ID.

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

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

With no annotations, the description carries the behavioral disclosure burden. It communicates that this is a non-mutating enumeration ('List every'), specifies the response content (name, description, manifests), and adds domain context about what an agent class is. It does not mention pagination or output format, but the output schema covers the latter and the operation is inherently read-only.

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

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

Two short sentences: the first conveys the core operation and returned data, the second provides a useful conceptual definition. There is no filler or repetition, and all content 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 parameterless listing tool with an output schema, the description is nearly complete: it names the exact resource scope and returned fields, and it explains the concept of an agent class. The only notable gap is the absence of explicit usage guidance relative to sibling tools, which is minor for such a low-complexity operation.

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 the schema confirms this with 100% coverage. The description adds no parameter-specific detail, but none is needed; the baseline for zero-parameter tools is 4, and the description satisfies it.

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'), a precise resource ('every agent class EFM manages'), and the exact fields returned (name, description, agent manifests). This clearly distinguishes it from sibling tools like efm_get_agent_class (single class) and efm_list_agents (agents rather than classes).

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 intended use is implied: call this to enumerate all agent classes rather than fetching one via efm_get_agent_class. However, the description does not explicitly state when to prefer this tool over siblings or mention exclusion cases, leaving some decision-making to inference.

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

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

With no annotations, the description carries the behavioral burden. It discloses that this is a read-style listing operation and what data it returns, including the heartbeat-derived online/offline semantics. It does not mention pagination, ordering, or failure behavior, but for a simple list tool this is adequate.

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 purpose and output fields, followed by precise parameter usage. Every sentence earns its place with no redundant wording.

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 operation is simple, has one optional parameter, and the description covers purpose, output meaning, and filter semantics. It could mention that valid agent_class values come from efm_list_agent_classes, but that is not essential for basic 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 only provides a field name and type, but the description explains the parameter's exact effect: passing agent_class filters to one class, omitting it returns every agent. This fully compensates for the low schema coverage and leaves no ambiguity about how to use the 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 ('List'), names the resource ('enrolled MiNiFi agents'), and states exactly what is returned (last-heartbeat timestamp, status/firstSeen/lastSeen). This clearly distinguishes it from sibling tools like efm_get_agent or efm_list_flows.

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

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

It explains when to use the tool ('primary online/offline signal') and gives explicit parameter guidance: pass agent_class to filter, omit it for all agents. It does not explicitly name alternatives for single-agent lookup, but the 'list' framing is clear enough.

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

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

With no annotations provided, the description carries the behavioral burden. It adds meaningful context: the resources are 'currently assigned' and are synced to agents 'on its next heartbeat,' which clarifies that this is a read-only snapshot tied to a synchronization cycle. It stops short of explicitly stating no side effects or auth requirements, but the verb 'list' plus the snapshot wording make the behavior reasonably transparent.

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 concise sentence with a dash-delimited clarification. Every phrase carries meaning, the core subject is front-loaded, and there is no redundant or filler 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 an output schema, the description covers the core semantics well. However, it leaves the agent_class parameter under-specified and does not mention how to discover valid class identifiers. Given the schema and output schema already exist, this missing parameter guidance is the main completeness 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 input schema has one parameter, agent_class, with no schema-level description, and schema description coverage is 0%. The description mentions 'one agent class' broadly but does not explain what agent_class values look like, where to obtain them, or any format constraints. This is a real gap for an agent trying to populate the only required 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 clear verb-resource pair ('list class resources') and then defines exactly what those resources are: assets/extensions EFM syncs to every agent in that class on its next heartbeat. This makes the tool's scope concrete and semantically distinguishable from siblings like efm_list_agent_classes and efm_list_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?

The description implies usage: call this when you need resources assigned to a single agent class. It does not explicitly state when to prefer this over efm_list_resources or other sibling tools, nor does it provide exclusions. Context is present, but alternative routing is left to inference.

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

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

With no annotations, the description carries the burden of behavioral disclosure. It does specify the output fields and that it returns one summary per agent class, but it doesn't mention whether results are cached, paginated, or if any authorization is needed. The output schema exists and likely covers return structure, but the description adds only minimal behavioral context beyond that.

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 fluff, front-loading the core output and immediately explaining its purpose. Every sentence earns its place, and the structure is clear.

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 no-parameter listing tool with an output schema, the description is largely sufficient. It tells the agent exactly what to expect and how to use it, though it leaves out minor details like error conditions or behavioral notes that might be useful but are not critical.

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 is trivially complete. The description adds no parameter-specific semantics because none are needed, earning the baseline of 4.

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 returns one summary per agent class with specific fields, and explicitly explains that this maps a class to the flowId needed by sibling tools efm_get_flow and efm_validate_flow. This differentiates it from other listing tools like efm_list_agent_classes.

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: it is the way to map an agent class to a flowId for subsequent calls to efm_get_flow or efm_validate_flow. It doesn't explicitly name alternatives or when not to use it, but the purpose is clear enough to guide 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?

No annotations are provided, so the description carries the full burden. It mentions the resource types and digest information, implying a read-only listing operation, but does not explicitly state that it is non-destructive or disclose any potential side effects such as pagination or rate limits. For a list tool, this is adequate but not comprehensive.

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 is front-loaded with the scope ('All resources in EFM's resource manager') and then provides specific details (types and digests). It is concise and every element adds value with no redundant 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 that the tool has no parameters and an output schema is present, the description provides sufficient context for an agent to invoke it correctly. It explains what resources are returned and their relevance (files EFM can push to agents), covering the essential information needed.

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 zero parameters, so the schema fully covers parameter semantics. The description adds no parameter-specific details, which is fine given the absence of parameters; the baseline of 4 applies.

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

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

The description clearly states it lists all resources in EFM's resource manager, specifying the resource types (assets and extension bundles) and the returned metadata (names, types, SHA-512 digests). This verb+resource pairing is unambiguous and distinguishes it from sibling tools like efm_list_class_resources, which focuses on class-level 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?

It provides context about the resources ('the files EFM can push to agents'), helping an agent understand the purpose, but does not explicitly mention when to use this tool versus alternatives like efm_list_class_resources. There is no direct comparison or exclusionary 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?

With no annotations provided, the description carries the full burden. It explicitly states 'without changing anything', clearly indicating a non-destructive read-only operation. It also explains the purpose (surfaces invalid/misconfigured components). While it doesn't describe error behavior or output format, the presence of an output schema covers that. The non-mutating trait is a key behavioral disclosure.

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 purpose ('Validation results for a flow') and immediately clarifies it is non-destructive. Every phrase earns its place; 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?

Given the tool has an output schema (which explains return values) and only one parameter, the description is largely complete. It covers purpose and non-destructive behavior. The only missing element is explicit usage guidance relative to sibling tools, but this is minor given the clear separation from other efm tools. The simplicity of the tool means the description suffices.

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 description does not elaborate on the flow_id parameter at all. Since schema description coverage is 0%, the description could have added context about what flow_id refers to, but the parameter name is self-explanatory and the schema provides its type. The description adds no value beyond the schema, which is minimal. For a single trivial parameter, this is acceptable.

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 validates a flow, surfacing invalid or misconfigured components. It uses a specific verb (validate) and resource (flow) and adds the context of being the same check EFM runs before publish. It doesn't explicitly distinguish from siblings, but no sibling appears to be a validation tool, so the 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?

The description implies the tool is used before publishing to validate a flow, but it does not explicitly state when to use it versus alternatives or when not to use it. No sibling tools are mentioned, and there is no guidance on exclusions or prerequisites. The publish context gives some usage hint, but it lacks explicit routing.

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