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

With no annotations provided, the description carries the full burden of disclosing behavior. It clearly warns that deletion is permanent, which is a critical destructive behavior beyond what the tool name alone conveys. It also specifies the store is the 'local vault'. It does not detail every edge case such as idempotency or behavior for missing hashes, but the most important behavioral trait is explicitly disclosed.

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 short sentences, front-loads the action and target, and adds the critical permanence warning without any filler. Every word contributes to the agent's understanding.

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

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

For a single-parameter destructive tool with no output schema, the description and schema together provide the essential context: what is deleted, how it is identified, where, and that the operation is irreversible. Minor missing details such as index or sync side effects could be helpful but are not necessary for safe invocation of this simple 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 100%, so the schema already fully documents the 'hash' parameter as the SHA-256 root hash. The description repeats this information without adding meaningful new semantics beyond the schema. This meets the baseline for a fully documented parameter but does not elevate 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 uses a specific verb ('Delete'), names the exact resource ('memory object'), identifies the targeting mechanism ('SHA-256 root hash'), and scopes the action to the 'local vault'. This clearly distinguishes it from sibling tools like vmn_ingest or vmn_list, and no ambiguity remains about what operation is performed.

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 is appropriate when a memory object must be removed permanently, and the unique verb 'Delete' makes it stand out from siblings. However, it does not explicitly state when to avoid using it, mention prerequisites such as verifying the hash first, or compare itself to alternative tools. Usage context is inferred rather than explicit.

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 of behavioral disclosure. 'Return the current status' reasonably implies a read-only operation with no side effects, and it adds the useful behavioral detail that the result indicates whether a rebuild is needed. However, it does not describe the output format, possible status values, or whether the status could be stale.

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

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

The description is two short sentences with no filler. It front-loads the main action and immediately adds the decision-relevant detail about rebuild necessity.

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 status-check tool, the description gives enough context to call it correctly and interpret the high-level result. The main gap is the absence of an output schema or return-value explanation, but the description's explicit mention of rebuild-need status substantially covers the practical need.

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 there is no parameter-description burden to satisfy. The schema fully covers the empty parameter set, and the description appropriately says nothing about parameters.

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 ('Return') and a specific resource ('BM25 inverted index'), and it clarifies the purpose by adding 'Indicates if a rebuild is needed.' This clearly differentiates the tool from siblings like vmn_rebuild_index without needing to open 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 when to use the tool: check status before deciding whether a rebuild is needed. However, it does not explicitly state when not to use it or point to alternatives such as vmn_rebuild_index for performing the actual rebuild. The usage context is clear but not fully explicit.

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 disclosure burden. It does reveal the mutation nature (ingestion into a vault), the local scope, and the return contract (a SHA-256 shard hash), which is useful beyond the schema. However, it is silent on duplicate handling, idempotency, error behavior, or what a 'shard' entails, so the behavioral disclosure is only partial.

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 filler: the first front-loads the action and target, and the second delivers the essential return-value contract. Every sentence earns its place and nothing is redundant.

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

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

For a tool with no output schema and no annotations, explicitly stating the return type is a meaningful step. However, given a shard-based architecture and ten siblings, the description doesn't explain how the returned hash is consumed downstream (e.g., by vmn_inspect or vmn_recall) or how text ingestion differs from file ingestion in practice, leaving notable context gaps for an agent exploring the vault toolset.

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

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

Schema description coverage is 100%, so the baseline of 3 applies. The description only reiterates that 'text' is what gets ingested and adds no meaning about how tags, namespace, or content_type interact with sharding or retrieval. It provides no value beyond the schema's parameter 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 specific action and resource — ingesting text into the local Vanguard Memory Vault — which clearly conveys what the tool does. The word 'text' implicitly distinguishes it from its sibling vmn_ingest_file, but the differentiation is not explicit, so it stops short of the top score.

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 no guidance on when to use this tool versus its ten siblings. It neither states when text ingestion is appropriate nor contrasts with vmn_ingest_file or the retrieval-oriented tools like vmn_recall and vmn_search. An agent is left to infer usage entirely.

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

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

With no annotations available, the description carries the full behavioral burden. It discloses the key non-obvious behavior: cursor-based deduplication, repeated-call safety, and that only new lines are stored. While it does not cover error handling or partial-failure behavior, the most important side-effect profile is 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?

Two compact sentences with zero filler. The first sentence front-loads the action and mechanism; the second adds the key safety guarantee. 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 5-parameter tool with no output schema, the description covers the essential non-obvious operational knowledge: incremental ingestion, cursor state, and repeatability. It could elaborate on what happens if the file changes in place or on mid-ingest failures, but the definition is sufficient for an agent to invoke 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 input schema has 100% description coverage: file_path, namespace, session_id, title, and tags are all explained. The description reinforces the cursor concept and the session_id role, but adds little beyond what the schema already provides. Baseline 3 is appropriate because the schema does the heavy lifting.

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

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

The description clearly states the action ('Ingest new content from a file'), the resource ('into the vault'), and the distinctive mechanism ('tracking progress with a cursor so only new lines are ingested'). This distinguishes it from the sibling tool 'vmn_ingest', which is presumably for non-file content, without needing to open 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 conveys the exact usage context: repeated calls are safe and only the delta since the last call is stored. This gives clear guidance for incremental file ingestion scenarios. It does not explicitly name alternative tools or exclusion conditions, but the context is strong enough to route an agent correctly.

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 full behavioral disclosure burden. It states the tool 'inspects' metadata, suggesting a read-only operation, but it does not disclose whether the operation is purely read-only, what the metadata format looks like, whether it errors on non-existent hashes, or any side effects. The limited description leaves important behavioral expectations unaddressed.

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 clear sentence with no extraneous content. It is front-loaded with the core action and resource, though it lacks any additional useful context. It earns a 4 for being appropriately concise and direct.

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, no annotations, and a single required parameter, the description does not explain the return value or structure of the metadata returned. An agent might need to know what 'catalog metadata' contains or how to interpret the response. The description is minimally sufficient for invoking the tool but incomplete for understanding the full context of its use.

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

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

Schema description coverage is 100%, so the schema already fully documents the single 'hash' parameter. The description adds minimal semantic value beyond the schema, but it does clarify that the hash is the SHA-256 root hash of the memory object being inspected, which is consistent with the schema. Baseline 3 is appropriate.

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

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

The description clearly states that the tool inspects catalog metadata for a memory shard using a SHA-256 root hash. It distinguishes itself from siblings like vmn_recall and vmn_search by specifying 'catalog metadata' rather than content or search results. However, it does not explicitly differentiate from vmn_list, though the hash-based selection makes this mostly 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 the tool is used when you have a specific known hash and need to inspect metadata, but it does not explicitly state when to use it versus siblings like vmn_recall or vmn_search. No alternatives or exclusions are mentioned, leaving usage context partially implied rather than explicitly guided.

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

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

There are no annotations, so the description carries the burden of behavioral disclosure. It clarifies that the tool lists objects from the local vault and supports optional namespace filtering, but does not mention return format, pagination, or whether full objects or metadata are returned.

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, information-dense sentences with the main action front-loaded and the optional filter stated directly. 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?

This is a simple list operation with one optional parameter and no output schema. The description covers the core behavior adequately, though it could be slightly more complete by noting what the returned listing contains.

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

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

Schema description coverage is 100% and the only parameter, namespace, is already documented as an optional filter in the schema. The description restates this without adding extra semantic depth.

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

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

The description uses a specific verb and resource: 'List all memory objects in the local vault.' It clearly conveys scope and optional filtering, distinguishing it from sibling tools like vmn_search and vmn_stats.

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 use when the agent needs to enumerate all memory objects or filter by namespace, but it does not explicitly contrast with alternatives such as vmn_search or vmn_recall. No when-not-to-use guidance is 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?

With no annotations provided, the description carries the full behavioral disclosure burden. It explicitly states a key safety property: 'objects are never modified,' which prevents an agent from fearing destructive side effects. It could add more detail about index replacement behavior, but it covers the most important operational concern.

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 deliver the core purpose, the source of data, and the safety guarantee. Every sentence earns its place and key information 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 maintenance tool with no output schema, the description provides sufficient operational context: what it rebuilds, from what data, and why it is safe. An agent can invoke this tool correctly without further information.

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 there is nothing for the description to clarify beyond the schema. The baseline score of 4 is appropriate because no parameter documentation 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 opens with a specific verb and resource: 'Rebuild the BM25 inverted index from existing vault objects.' This clearly distinguishes it from read/search/status siblings like vmn_search or vmn_index_status, making the tool's purpose unmistakable.

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

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

The statement 'Safe to run at any time' gives explicit usage context and implies there are no scheduling or precondition constraints. It does not explicitly name alternatives, but the purpose is clear enough that an agent can infer when to choose this over status or search 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?

With no annotations, the description carries the behavioral burden. It does add useful behavioral details: the search is 'deterministic,' uses 'lexical search,' and operates on a 'local' shard, implying read-only retrieval. It does not describe result format, errors, or edge cases, but for a simple recall tool this is acceptable.

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 one efficiently structured sentence that front-loads the action and resource before the method. There is no filler or repetition of schema details, making it easy to scan.

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 two required, fully documented parameters and no output schema, this is a reasonably complete description. It states the purpose, scope, and search behavior, though it could briefly mention result behavior or when to prefer this over vmn_search.

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 already covers both parameters at 100%: hash is described as the SHA-256 shard hash from vmn_ingest, and query is the search query. The description adds no parameter-level meaning beyond what the schema provides, so the baseline of 3 applies.

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

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

The description uses a specific verb ('Recall') and resource ('local Vanguard Memory shard'), and adds the method 'deterministic xLMP lexical search,' so it clearly states what the tool does. However, it does not explicitly contrast with siblings like vmn_search or vmn_list, so some distinguishing context is left to inference.

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

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

There is no explicit when-to-use or when-not-to-use guidance, and no mention of alternatives such as vmn_search or vmn_inspect. The required hash from vmn_ingest is a contextual clue, but the description does not tell an agent how to route between the 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?

No annotations are provided, so the description carries the full burden of behavioral disclosure. It does add useful context: the search operates across all memory objects and returns only candidate roots rather than full evidence. However, it does not disclose whether the operation is read-only, how limit or namespace parameters affect behavior, or any ordering/pagination details, leaving clear gaps.

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

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

Three short sentences, each contributing distinct information: the search action and scope, the output form, and the routing to vmn_recall. There is no filler or redundancy, and the most important information 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 relatively simple 3-parameter search tool with no output schema, the description provides the essential output expectation ('Returns candidate roots') and onward guidance to vmn_recall. The parameter semantics are fully covered by the schema. It could add a note about namespace behavior or the meaning of 'candidate roots', but the definition is largely complete for an agent to invoke it successfully.

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

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

Schema description coverage is 100%, so the schema already documents all three parameters (query, limit, namespace) with descriptions. The tool description adds no additional parameter semantics beyond the phrase 'keyword query', which maps to the query parameter, so the baseline score of 3 is appropriate.

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

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

The description uses a specific verb ('Search'), identifies the resource ('all memory objects in the vault'), and states the output ('Returns candidate roots'). It also distinguishes the tool from its sibling vmn_recall by clarifying that recall retrieves full evidence, so an agent can tell them apart.

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 clearly states the tool's scope ('across all memory objects in the vault') and gives an explicit alternative: 'Use vmn_recall with a specific root to retrieve full evidence.' This provides helpful routing, though it does not explicitly list exclusions or when-not-to-use conditions beyond that single alternative.

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 of behavioral disclosure. It states the tool returns statistics, but does not explicitly confirm it is read-only, describe side effects, explain what the statistics represent, or mention any constraints. This leaves the agent with only a surface-level understanding.

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 clear sentence with no wasted words. It front-loads the action and scope, making it easy to parse quickly despite not being expansive.

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 tool, the description is minimally viable: an agent knows the call has no inputs and returns statistics about the local vault. However, without an output schema, the description does not say which statistics are returned,, making the tool's behavior somewhat underspecified for an agent that must reason about results.

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 complete and there are no parameter semantics for the description to clarify. The baseline of 4 applies because there is nothing ambiguous about an empty input 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 action ('Return statistics') and the resource ('local Vanguard Memory Vault'). It distinguishes the tool's general purpose from write-oriented siblings, though it does not explicitly contrast it with similar informational siblings like vmn_index_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 gives no guidance on when to choose this tool over alternatives such as vmn_index_status, vmn_list, or vmn_inspect. It implies the tool is for retrieving statistics but does not specify contexts, exclusions, or relationships to 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?

With no annotations provided, the description carries the full disclosure burden. It does add one useful behavioral fact — the EXERGYNET_API_KEY requirement — but it leaves the core behavior of 'sync' unexplained: whether it pushes one-way, overwrites existing vault entries, merges, is idempotent, or what side effects occur on hash conflicts. For a mutation-style operation, this is a significant 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 sentences with zero waste: the first front-loads the action and destination, the second delivers the essential invocation prerequisite. 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?

Despite low complexity (2 params, 1 required), the lack of annotations and output schema means the description must explain operation effects, and it does not. An agent cannot tell whether syncing updates an existing vault object, creates a new one, overwrites, or how to verify success. The env var disclosure is helpful but insufficient for a remote-mutation 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 coverage is 100%, so the baseline of 3 applies. The schema already fully documents both parameters, including the SHA-256 root hash semantics for xlmp_root and the default for intent. The description merely echoes 'local memory object' without adding any parameter-level detail beyond the schema.

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

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

The description names a specific verb ('sync'), a specific resource ('local memory object'), and a specific destination ('ExergyNet LNES-17 vault'). This distinguishes it from the sibling tools — none of which describe syncing to a vault — and there is no tautology with the tool name.

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

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

The description offers no guidance on when to choose sync over the sibling tools, particularly vmn_ingest or vmn_ingest_file, whose purposes overlap somewhat with pushing data into the system. The env var note is a prerequisite, not usage guidance — it says nothing about when or when not to call this tool.

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