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

No annotations are provided, so the description carries full behavioral burden. 'Store' implies a persistent mutation, but the description does not say whether it overwrites, how duplicate aliases are handled, whether the entry is immediately searchable, or what is returned. The placeholder mention is the only real behavioral signal.

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 spends its words on the distinguishing element (templated snippets) rather than restating the name. Appropriately sized, though it could redirect to siblings in the same breath.

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?

Six parameters, no annotations, no output schema, and a write tool whose uniqueness/lookup contract is undocumented — an agent cannot tell from this description whether alias collisions are rejected, merged, or stored as duplicates, nor how stored placeholders are filled at retrieval.

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 six parameters are already documented in the schema; the description's only added value is explaining the template/placeholder semantics of the command field. Baseline 3 is correct when the schema does the heavy lifting.

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

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

Specific verb ('Store') plus specific resource ('command snippet or instruction recipe') and a distinguishing detail: placeholders like {{input}}. It separates itself from get_instruction/search_instructions by being the write side, but it never states how it differs from save_entry or save_entry_ref, which also store 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?

There is no statement of when to use this versus save_entry, save_entry_ref, or save_artifact, and no prerequisites or exclusions. An agent facing a write operation with many sibling write tools has to guess based on the name 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?

No annotations are provided, so the description carries the full burden of behavioral disclosure. It states that a bookmark is stored, but does not mention persistence semantics, duplicate or alias collision handling, permission requirements, or whether the operation is reversible. For a mutation tool with zero annotation coverage, this is a meaningful gap.

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

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

The description is a single, waste-free sentence with the core verb and resource front-loaded. It is appropriately sized for the amount of information it conveys.

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 six-parameter mutation tool with no annotations and no output schema, so the description should do more to explain behavior, side effects, and expected outcome. The current sentence is too thin for an agent to confidently understand the full contract of storing a bookmark.

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 all six parameters are already documented in the input schema. The description mentions URL and alias but does not add syntax, format, or behavioral meaning beyond what the schema provides, making the baseline score 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 and resource: "Store a URL bookmark" with an alias keyword. This is clear enough for an agent to distinguish it from read-side siblings like get_link, search_links, and list_links, though it does not explicitly differentiate it from save_entry or save_entry_ref.

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 "for quick retrieval" implies a use case, but there is no explicit guidance on when to use this tool versus alternatives such as save_entry, save_entry_ref, or save_artifact. The agent is left to infer the appropriate 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?

With no annotations, the description carries the full behavioral burden. It usefully discloses that this is a soft delete that changes status to archived, but does not state whether the operation is idempotent, what permissions are required, whether archived entries remain searchable, or what the call returns.

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 with no wasted words. The key mechanism, soft deletion via status change, is front-loaded and 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 one-parameter mutation tool with no annotations or output schema, the description covers the essential effect but leaves open important behavior such as permissions, reversibility, and return format. It is minimally adequate rather than 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 100%, and the single parameter is already documented as 'Entry ID'. The description adds no additional syntax, format, or validation details beyond what the schema provides, so the baseline score 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 phrase ('Soft-delete') and resource ('an entry') and clarifies the mechanism ('set status to archived'), making clear this is not a hard delete or a save operation. It distinguishes the action from siblings like save_entry or get_entry, though the noun 'entry' remains broad across many sibling 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?

It does not state when to choose this over alternatives, such as restore_entry_version for undoing an archive or save_entry for updating an entry. There are no exclusions or prerequisite conditions.

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

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

With no annotations, the description carries the full behavioral burden. It usefully discloses the diff algorithm and output format ('line-based LCS unified diff'), but does not describe prerequisites such as whether entries must exist, error behavior, or read-only implications.

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

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

A single front-loaded sentence with zero waste. It efficiently conveys the operation and output format.

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

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

For a simple two-parameter read-only comparison tool with no output schema, the description is mostly sufficient: it names the diff algorithm and output format. It omits edge-case behavior and explicit usage context, but the tool's complexity is low.

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

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

Schema coverage is 100%, so both id1 and id2 are already documented. The description confirms they are entries to compare, but adds no syntax or format detail beyond the schema.

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

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

The description states a specific verb and resource: compute a line-based LCS unified diff between two entries. No sibling tool does comparison or diffing, so it is clearly distinguishable.

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 usage is implied by the phrase 'between two entries', but the description does not explicitly say when to use this tool versus alternatives or when not to use it. It gives enough context to infer the basic use case but no routing guidance.

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

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

No annotations are provided, so the description carries the full behavioral burden. It hints at ordering ("ordered entries") but never states the ordering criterion, whether the call is read-only, what happens for an unknown or empty series, or what the response shape looks like. That is thin coverage for a tool with zero annotation support.

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 short sentence with no filler and the key concept front-loaded. It is efficient rather than padded, though its brevity borders on under-specification rather than true economy.

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 annotations, no output schema, and zero required parameters (series_id is optional per the schema), the description should clarify what happens when series_id is omitted and what "ordered" guarantees. Neither is addressed, leaving an agent guessing about core call behavior.

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 single parameter is documented (albeit circularly as "Series ID"). Baseline 3 applies; the description adds nothing about format or semantics of series_id, but the schema does the documented work.

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 ("Return") and resource ("ordered entries in a series"), which is clearer than a tautology. However, it never defines what a "series" is or how this differs from siblings like get_entry, get_entry_graph, or list_entry_refs, which all sound like they could return related entries.

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 when-to-use guidance, no exclusion criteria, and no mention of alternatives among the ~38 sibling tools. An agent cannot tell from this text whether compose_series or get_entry_graph is the right call for related content.

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 must carry the full behavioral burden. It implies a read-style compilation from vault data but does not disclose permissions, side effects, performance characteristics, output size behavior, or what happens across the several modes.

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 front-loaded sentence with no wasted words. It is not verbose, though its brevity contributes to gaps captured in other dimensions.

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 complex tool with six optional parameters, multiple modes, section selection, size limits, and no output schema. A seven-word description is not sufficient to explain the modes, expected outputs, or how the compiled pack should be used.

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 all six parameters are already documented in the schema. The description adds no parameter-level meaning beyond what the schema provides, which is the baseline 3 for high 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 gives a verb ('Compile') and a resource ('context pack from vault data'), so the general purpose is identifiable. However, 'agent-ready context pack' is vague jargon and the description does not clarify what the pack contains or how it differs from siblings like get_context_bundle or vault_mem_context.

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 on when to use this tool, when not to use it, or which sibling tools are alternatives. The agent must infer usage from the name 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?

With no annotations provided, the description carries the full disclosure burden. It does useful work by naming the return shape (structured JSON with grouped entries and artifact refs), which is the most important behavioral fact for a read tool with no output schema. It says nothing about read-only safety, size/volume of the bundle, or whether missing projects error or return empty, leaving real 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?

A single front-loaded sentence with no filler; the payload inventory comes first. It is slightly terse given the agent still needs scoping guidance, but nothing is wasted.

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

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

For a low-complexity read tool with one optional parameter and no output schema, the description covers the essentials of what comes back. It stops short of clarifying whether results include historical versions, how large the bundle may be, or what happens with an omitted project, which an agent would need to call it confidently.

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

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

Schema coverage is 100% and there is only one optional parameter (project), which the schema already documents as 'Project name or ID'. The description adds no format or scoping detail beyond that, so the baseline 3 applies.

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

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

States a specific verb (Return) and enumerates the three payload components (project info, entries grouped by type, artifact refs), which is concrete and distinguishes it from entry-level tools like get_entry. However, it does not differentiate itself from the closely-named sibling get_context, leaving genuine ambiguity about which to pick.

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

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

There is no statement of when to use this bundle versus get_context, get_entry, or get_entry_graph. The agent must infer that it is a bulk aggregation call from the description alone, with no explicit context or 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, the description carries the full burden; "Get" does imply a read-only operation and the parenthetical discloses that linked artifact references are included in the response, which is genuine added context. It still says nothing about behavior when the ID is unknown, whether access is scoped, or how large an entry can be, which matters for an unannotated 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?

One short sentence with the action and key front-loaded and no filler. The parenthetical is the only extra clause and it carries real 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?

For a single-parameter read with no output schema, the description covers what is returned at a high level (entry plus artifact reference when linked) and how it is addressed. Missing error/not-found behavior and any notion of what a vault entry contains keeps it from being fully 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 coverage is 100% and the single parameter is documented as "Entry ID", so the schema already does the work. The description only restates that lookup is by ID and adds no format or sourcing hints for the identifier, so baseline 3 applies.

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

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

"Get a vault entry by ID" states a specific verb and resource with the retrieval key, which is unambiguous. It does not, however, distinguish itself from near-neighbors such as get_entry_graph, get_context_bundle, or vault_mem_get, so an agent must still infer the boundary.

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

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

The phrase "by ID" implies a prerequisite but the description never states when to choose this over list_entry_versions, get_entry_graph, or vault_mem_get. No exclusions, no alternative routing, nothing beyond the bare retrieval action.

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 implies a read-only traversal but never states cycle handling, truncation or result capping at max_depth, behavior when entry_id doesn't exist, or the cost/shape of the returned graph — all significant for a traversal that can expand exponentially.

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

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

A single front-loaded sentence with zero filler. It is efficient, though its brevity verges on under-specification rather than optimal sizing.

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 4-parameter read tool with a fully documented schema and no output schema, the description covers the core action but omits return-shape hints and traversal limits. Given no annotations and no output schema, the description should do slightly more to be 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 100%, so entry_id, direction, max_depth (default 3, max 10), and ref_types are already fully documented in the schema. The description adds no param-level detail beyond that, so the baseline of 3 applies.

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

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

States a specific verb (traverse) and resource (entry graph) plus what it returns (connected nodes and edges). It is distinguishable from siblings like list_entry_refs or get_entry, though it does not name or contrast with them explicitly.

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

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

There is no guidance on when to use this versus list_entry_refs, get_context_bundle, or compare_entries, and no stated preconditions or exclusions. The usage is only inferable from the verb 'traverse'.

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, but 'retrieve' and 'latest' disclose the core read/ordering behavior. It still omits important details such as whether the operation is strictly read-only, what happens when no handoff exists, or any permission requirements.

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 front-loaded sentence with no wasted wording. It immediately communicates the action, target, and filtering scope.

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 retrieval tool with fully described optional parameters, the description is largely sufficient: it names the returned resource and its latest semantics. The lack of output schema means return shape is not described, but that is a minor omission for this straightforward lookup.

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

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

Schema coverage is 100%, so both optional filter parameters are fully documented in the schema. The description mentions project and task_id scoping but adds no syntax, precedence, or format details beyond what the schema already provides, making baseline 3 appropriate.

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

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

The description clearly states a specific verb and resource: retrieve the latest agent-to-agent task handoff. It does not explicitly name a sibling such as save_handoff, but the retrieval framing makes the operation distinct from saving a handoff.

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 indicates that the handoff can be scoped by project or task_id, which implies filtering usage. However, it gives no explicit guidance on when to use this tool versus alternatives such as get_context_bundle, nor any prerequisites or 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?

As no annotations are provided, the description adds important functional context by mentioning 'variable interpolation.' This is a specific behavioral trait of how the instruction is resolved, making it more helpful than a generic retrieval description.

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 definition is a single, highly efficient sentence. It front-loads the core functionality (resolve by alias) and includes a key operational detail (variable interpolation) without unnecessary words.

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

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

For a retrieval tool, the description is quite complete in terms of inputs. However, since there is no output schema, the description lacks crucial information about the expected return format (e.g., JSON object, raw string, structure).

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?

With schema description coverage at 100%, the baseline for parameter semantics is 3. The description only reinforces the optional nature of 'vars' by linking it to variable interpolation, adding minimal value beyond the existing schema definition.

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 ('Resolve') and the mechanism ('by alias'). It is specific but could benefit from explicitly stating that it retrieves a single item, contrasting it with sibling search or list 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?

There is no guidance on when this tool should be used relative to its siblings. It fails to specify, for example, that the alias should be used when the exact instruction name is known, leaving the agent to infer the appropriate lookup method.

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

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

No annotations are provided, so the description carries the full behavioral burden. It implies a read that returns a URL, but says nothing about behavior when the alias is unknown (error vs null), whether expired/disabled aliases resolve, or any permission requirements.

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

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

One front-loaded sentence with no filler. It is efficient, though its brevity borders on under-specification that the other dimensions penalize.

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 tool with a fully documented schema and no output schema, the description implies the return (the stored URL). However, with no annotations, it should say more about failure modes and whether the returned URL is raw or a redirect target.

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% and the single parameter is documented as 'Alias keyword to resolve (required)'. The description's wording mirrors the schema rather than adding format, case-sensitivity, or resolution-scope details, so the baseline 3 applies.

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

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

States a specific verb ('resolve') and resource ('alias keyword' → 'stored URL'), making it distinguishable from siblings like search_links, list_links, and add_link. It does not explicitly name or contrast those siblings, keeping it just short of a 5.

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

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

No guidance on when to use this versus search_links, list_links, or get_link's counterpart add_link. The single sentence gives no exclusions, prerequisites, or selection criteria.

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 does disclose what the response contains ('with its step details'), which is useful beyond the schema, but it says nothing about read-only semantics, behavior when the run_id is unknown, or result size.

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

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

A single front-loaded sentence with no filler. The returned-content hint is placed before the object of the action, so nothing is wasted.

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

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

For a one-parameter read tool with a fully described schema and no output schema, this covers the essential purpose and return content. Minor gaps: no error/missing-run behavior and no note that this is a non-mutating read.

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

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

Schema description coverage is 100% and the single run_id parameter is already documented in the schema as required. The description adds no format, example, or sourcing guidance beyond that, so the 3 baseline applies.

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

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

States a specific verb and resource ('Get a single workflow run') plus a scope hint that it includes step details. This implicitly separates it from list_workflow_runs, but the sibling is never named.

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

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

Usage is only implied: 'single' suggests fetching one run's detail as opposed to listing runs, but there is no explicit when-to-use, when-not-to-use, or reference to list_workflow_runs as the 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. It only states 'return statistics,' which fails to disclose crucial behavioral traits like the time window covered (e.g., last 7 days, all-time), aggregation level, or if certain critical metrics are excluded.

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?

It is a single, efficient sentence that front-loads the resource and action. It is appropriately sized and contains no fluff.

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 this is a statistics-gathering tool, the description must define its scope. Since it offers no time constraints or metrics breakdown, it remains minimally viable but lacks the necessary completeness for an AI to confidently choose it over similar reporting functions.

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, meaning the input schema requires no description. As such, the description cannot add semantic meaning beyond what is in the structured data. The baseline score for 0 parameters is 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 identifies the action ('Return') and the resource ('vault statistics and workflow run analytics'). While specific, it is a bit generic compared to listing specific run metrics, giving it a solid 'clear' rating without being overly precise.

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 use this tool versus other available statistical or listing tools (e.g., list_workflow_runs). There are no 'when-not' scenarios or usage context 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?

No annotations are provided, so the description carries the full disclosure burden. 'List' weakly implies a read, but nothing states that explicitly, nor does it describe pagination, default filtering behavior, or whether archived refs are excluded by default. For a no-annotation tool this is a substantial gap.

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

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

A single front-loaded sentence with zero filler. It's efficiently structured, though the brevity overlaps with the completeness gaps rather than being a flaw of verbosity.

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 annotations, no output schema, and an unstated default for include_archived, the description leaves the agent guessing at the return shape and default scope. It should at minimum say what a ref/edge record contains and whether archived refs are returned by default.

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 each of the four filters is already documented in the schema, establishing a baseline of 3. The description adds nothing beyond that (e.g., how multiple filters combine, or the default for include_archived), so it does not exceed the baseline.

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

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

States a specific verb (List) and a specific resource (graph edges between entries), so an agent knows it enumerates relationship records rather than entries themselves. It doesn't explicitly differentiate itself from the closest siblings (get_entry_graph, save_entry_ref), but the verb+resource pairing is clear enough to route on.

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 statement of when to use this versus get_entry_graph or save_entry_ref, and no mention that all four filters are optional (so it can enumerate everything). The agent must infer usage context purely from the name.

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 load. 'List' implies a safe read, and 'descending by version number' conveys sort order, but pagination, limits, and what happens when an entry has no versions are unstated.

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

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

One short sentence, front-loaded with the core action, with the ordering hint in parentheses. Nothing is redundant, though the extreme brevity borders on under-specification for a tool with no annotations.

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

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

For a single-parameter read tool with no output schema, the description is minimally sufficient but does not describe the shape of the returned version records or whether the list is bounded. It stops at 'adequate' rather than telling the agent what it will actually get back.

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% and the single entry_id parameter is already documented as required in the schema. The description adds only the ordering semantics of the result set, not any meaning about the parameter itself, so the baseline 3 applies.

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

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

The description gives a specific verb and resource ('List version history for an entry') plus a scope detail (descending by version number). It reads clearly as a read-only listing operation and is distinguishable in practice from the sibling restore_entry_version, though it does not name that sibling explicitly.

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

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

Usage is only implied by the verb 'List'; there is no statement of when to call this versus restore_entry_version or get_entry, and no preconditions are mentioned. An agent can infer intent but gets no explicit routing guidance.

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

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

No annotations are provided, so the description carries the burden; 'List all stored' implies a read-only, non-destructive retrieval, but ordering, result volume, and pagination behavior are unstated. For a simple read-only list tool this is a modest gap rather than a serious one.

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 tight sentence with the scoping behavior front-loaded and no filler. Nothing could be removed without losing 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?

For a one-optional-parameter list tool with no output schema and no annotations, the description is adequate but thin: it says nothing about what an instruction recipe record contains or whether results are truncated, which is the kind of context the description would need to supply here.

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% for the single optional 'project' parameter, so the schema already documents it. The description restates the filter behavior without adding matching semantics (exact name vs. slug, case sensitivity), making it baseline.

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?

Clear verb ('List') and resource ('stored instruction recipes') with an explicit scoping clause about project filtering. It doesn't name the sibling search_instructions or get_instruction, so the agent must infer the boundary between listing and searching, but the core 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 phrase 'optionally filtered by project' implies when the parameter is useful, but there is no explicit guidance on when to prefer this over search_instructions or get_instruction. Usage is inferable from the verb but not spelled out.

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

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

With no annotations, the description carries the full disclosure burden; 'list all stored' implies a safe read with no mutation, which is useful. However, it says nothing about pagination, result ordering, or whether the project filter is exact-match, all of which affect how an agent should call 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?

One short sentence with the resource front-loaded and the optional filter trailing; every word carries information and nothing is padded.

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 tool with full schema coverage and no output schema, the description covers the essentials. The only gap is return behavior (ordering/pagination), which is minor for this complexity level.

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% and the single parameter already carries a description ('Filter by project (optional)'), so the description's mention of the project filter adds little. Baseline 3 is appropriate when the schema does the work.

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

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

States a specific verb (list) and resource (stored URL bookmarks) with scope ('all'), which is enough to tell it apart from add_link/get_link by implication. It never names search_links explicitly, so the boundary between listing everything and searching is left for the agent to infer.

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 'optionally filtered by project' implies when the parameter is worth using, but there is no explicit guidance on when to choose this over search_links or when not to call it. Usage is implied rather than stated.

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

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

With no annotations, the description carries the full behavioral burden. It discloses that the tool returns all projects and includes statuses, which implies a broad read operation, but it omits pagination, permission scope, ordering, and whether 'all' is truly unbounded.

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?

It is a single front-loaded sentence with no filler, and the return content is mentioned efficiently. It could be slightly stronger by naming the status field or output shape, but it is appropriately sized for a simple zero-parameter list operation.

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

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

For a simple zero-parameter read with no output schema and no annotations, the description is minimally adequate: it states the resource and that statuses are included. It does not explain the return structure, whether projects are scoped to the caller, or how large the result may be.

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 input parameters, so parameter semantics are not a meaningful area of concern. The schema requires nothing, and the description does not falsely imply any filtering or input options.

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 ('List') and resource ('projects') and states the returned content ('statuses'), so the core purpose is immediately understandable. However, it does not differentiate this tool from the many other listing/search sibling tools, so an agent must infer that it is specifically for projects.

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 guidance about when to use this tool versus alternatives such as search tools, entry-listing tools, or other retrieval siblings. It also gives no conditions, prerequisites, or exclusions to help an agent choose it 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 the full behavioral burden. It implies a read operation and hints that each run carries step progress, but says nothing about ordering, pagination beyond the limit parameter, which projects/runs are visible, or result shape — significant gaps for an unannotated 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?

A single front-loaded sentence with no filler. It is tight, though the brevity is also the source of the missing guidance rather than a model of economy.

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

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

For a two-parameter, zero-required read tool with no output schema, the description covers the essentials but leaves ordering, default scope, and what a "run" record contains unexplained. Adequate, 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 coverage is 100%, with both limit and workflow_id documented inline, so the schema already does the work. The description adds only the notion that filtering is optional and that step progress is included, which is marginal added meaning.

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+resource ("List workflow runs") plus the two things that shape the result: an optional workflow filter and inclusion of step progress. It does not differentiate from the sibling get_run, which plausibly fetches a single run, but an agent can still tell what this returns.

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 word "optional" is the only usage cue; there is no statement of when to prefer this over get_run or how results are scoped. An agent must infer the list-vs-get split from the name 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?

With no annotations, the description must carry behavioral context. 'Return' implies read-only behavior and 'as a checklist' discloses the output style, which is useful, but permissions, missing workflow_id behavior, and error handling are unstated.

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 front-loaded sentence with no filler. It immediately states the operation and result format.

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

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

No output schema exists, so the description should clarify what the checklist contains, but it does not. Since workflow_id is not required, the description also should explain what happens when it is omitted, which it leaves unaddressed.

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 single workflow_id parameter is already documented in the schema. The description adds no additional meaning about the parameter's format or optionality, so baseline 3 applies.

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

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

The description states a specific verb and resource: 'Return workflow steps' plus an output format, 'as a checklist'. It is clear what the tool does, but it does not distinguish itself from siblings such as run_workflow or list_workflow_runs.

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 on when to use this tool versus run_workflow or list_workflow_runs. The word 'Return' implies a read-only viewing operation, but the description does not state prerequisites or selection criteria.

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

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

No annotations are provided, so the description carries the full behavioral burden. It implies a mutation but does not disclose whether restoring overwrites the current version, creates a new version, requires permissions, or is reversible.

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, front-loaded sentence with no unnecessary detail. It is efficiently sized for the tool's stated action.

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 mutation tool with no annotations and no output schema, the description is incomplete. It does not explain side effects, reversibility, required permissions, or how the restore interacts with existing entry versions.

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 both entry_id and version_number are already documented in the input schema. The description adds only the phrase 'by version number,' which is already evident 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 a specific verb and resource: restore an entry to a previous version. It clearly distinguishes the action from siblings like list_entry_versions or compare_entries, though it does not explicitly name those alternatives.

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 basic use case but gives no explicit guidance on when to use this tool versus alternatives, prerequisites, or workflow context such as needing list_entry_versions to discover a version number.

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 disclosure burden and does not meet it. It never says whether routing only selects a candidate or also executes it, how ambiguity or multiple matches are handled, or whether the match is authoritative — all critical for a dispatcher-style 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?

A single front-loaded clause with zero padding; every word earns its place. It is appropriately sized, though its brevity is achieved by omitting rather than compressing.

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 annotations and no output schema, the description must explain the response contract, and it does not: an agent cannot tell whether it receives a workflow ID, a name, a ranked list, or a confidence score. That gap matters greatly when the very next step is a decision to call run_workflow.

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% for the single 'scenario' parameter, so the baseline is 3. The description adds only the phrase 'free-text', implying unconstrained natural language rather than an ID or slug, but offers no guidance on length, phrasing, or what makes a matchable scenario.

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 ('Resolve') and the transformation ('free-text scenario' -> 'matching workflow or skill'), which is far more than a restatement of the name. It does not, however, distinguish itself from siblings such as run_workflow or search_by_tags, so an agent cannot tell from this text alone how routing differs from searching or executing.

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 when-to-use guidance, no 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?

No annotations are provided, so the description carries the full behavioral burden. It discloses that per-step results are returned, but says nothing about side effects, permissions, idempotency, partial failures, or what happens if a step fails—important gaps for an execution 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 a single front-loaded sentence with no wasted words. It states the action, the input shape, and the return shape efficiently.

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

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

For an execution tool with no annotations and no output schema, the description is too thin. It should explain prerequisites, whether execution is synchronous or asynchronous, failure semantics, and what 'per-step results' contains, especially given the nested step 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?

Schema description coverage is 100%, so the schema already documents both parameters, including the nested step map. The description does not add syntax or format detail beyond the schema, but the baseline of 3 is appropriate when the schema does the heavy lifting.

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

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

The description states a specific verb (Execute) and resource (a workflow), and adds that it accepts structured step inputs and returns per-step results. This is clear enough for an agent to understand the tool's core function, but it does not explicitly distinguish it from nearby siblings like render_workflow or list_workflow_runs.

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 guidance on when to use this tool versus alternatives such as render_workflow, list_workflow_runs, or get_run. The description implies execution but provides no conditions, prerequisites, or 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?

No annotations are provided, so the description must carry the full behavioral burden. It says nothing about overwrite behavior, permissions, how content vs file_path is resolved, validation failures, or what happens to an existing artifact with the same title.

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 front-loaded sentence with no wasted wording. However, it is arguably too terse for a seven-parameter save tool, so it is concise but under-informative.

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 mutation tool with seven parameters, no annotations, and no output schema, the description is not complete enough. It omits when to use it, how content and file_path relate, what artifact types are for, and what the save operation returns or overwrites.

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 high at 86%, so the schema already documents most parameters including type, title, content, file_path, project, and summary. The description adds only the general notion of a long AI output or file-backed artifact and does not clarify parameter interactions beyond what the schema 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 description gives a clear verb and resource ('Save a ... artifact') and narrows the scope to 'long AI output or file-backed artifact.' It does not differentiate from close siblings such as save_entry, save_result, save_handoff, or vault_mem_save, so it falls short of a 5.

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

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

There is no explicit guidance on when to use this tool versus save_entry, save_result, vault_mem_save, or save_handoff. The phrase 'long AI output or file-backed artifact' implies a use case but does not state exclusions or selection criteria.

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

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

No annotations are supplied, so the description carries the full behavioral burden, yet a single sentence says nothing about whether this creates or overwrites an entry with a matching title, what permissions are needed, whether it is reversible, or what identifier is returned. Only the word 'Save' signals mutation. It does not contradict structured data, but it leaves almost every behavioral trait undisclosed.

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 short sentence with the verb and resource front-loaded and no padding. It is efficient, though the terseness borders on under-specification for an 8-parameter mutation tool.

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

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

With 8 parameters, no annotations, no output schema and no description of required fields (the schema even marks required: [] while title says '(required)'), the description should explain lifecycle and return behavior. It does not, leaving the agent under-informed for a write tool.

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

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

Schema description coverage is 88%, so the schema already documents body, type, title, status, project, purpose and summary. The description's 'prompt, skill, decision, etc.' merely previews the type enum already listed in the schema, adding no syntax, defaults, or format detail. 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?

States a specific verb and resource ('Save a vault entry') and grounds the abstract 'entry' with concrete examples (prompt, skill, decision), so the agent knows what kind of object is created. It does not distinguish this from siblings such as save_entry_ref, save_artifact, save_handoff or vault_mem_save, so the agent cannot tell which save path applies.

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

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

There is no statement of when to use this tool versus the many sibling save/compose tools, no prerequisites, and no exclusions. The only guidance is implied by the parenthetical type examples, which is not enough to route reliably across ~35 siblings.

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, so the description carries the full behavioral burden, and it is thin. It does not explain what determines create vs update (identity key — source+target+relation_type?), whether an existing edge is overwritten or duplicated, whether the label is replaced on update, or what permissions are required for a graph mutation.

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

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

A single front-loaded sentence with zero filler. It is efficient, though the brevity is partly under-specification rather than disciplined compression.

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?

A mutation tool with no annotations, no output schema, and a non-obvious upsert semantic needs more than one clause. The agent is left unsure what happens on conflict, whether the call is idempotent, and what is returned.

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

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

Schema coverage is 100%, so all four parameters including the relation_type value list are already documented in the schema. The description adds only the graph-edge framing and nothing about parameter interaction (e.g., required source/target despite zero required fields declared).

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 pair and resource: create/update a link between two entries, qualified as a graph edge. The distinction from the sibling add_link is not addressed, and 'create or update' leaves the upsert trigger ambiguous, but the operation itself 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?

No when-to-use guidance, no prerequisites, and no mention of the obviously competing siblings add_link, get_link, or list_entry_refs. The agent must infer from the name alone whether this or add_link is the right call.

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

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

No annotations are provided, so the description carries the full behavioral burden, yet it says nothing about persistence semantics, whether saving overwrites an existing handoff for the same task_id, required fields, or what is returned. The phrase 'structured ... checkpoint' hints at durable state, but an agent cannot tell from this whether the call is safe, idempotent, or how failures surface.

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 front-loaded sentence with no filler, so it is efficient. Its brevity is more a completeness problem than a conciseness problem, but the size itself is appropriate.

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 six-parameter mutation tool with no annotations and no output schema, the description is too thin: it omits when to hand off, what happens to an existing handoff for the same task_id, and what the caller should expect after saving. The schema covers parameters, but the behavioral contract of the save operation is left largely unspecified.

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 all six parameters (project, task_id, next_steps, step_summary, blocking_issues, artifacts_produced) are already documented in the schema. The description adds no field-level meaning beyond the schema, which is acceptable given the high coverage baseline.

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 (Save) and a specific resource (a structured agent-to-agent task handoff / checkpoint), which is meaningfully narrower than generic siblings like save_entry or save_result. It does not explicitly contrast itself with get_handoff or clarify the checkpoint vs handoff distinction, 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?

There is no guidance on when this tool should be used instead of save_entry, save_entry_ref, or save_result, nor when not to use it. The only hint is the phrase 'agent-to-agent', which implies a multi-agent handoff context but is not operationalized.

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 must carry the full behavioral burden, but it only discloses that this is a write operation creating a vault entry. It says nothing about permissions, overwrite or duplicate-name behavior, validation failures, or whether saving is 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?

The single sentence is front-loaded and contains no filler. It is arguably too terse for an eight-parameter mutation tool, but it does not waste words.

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

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

For an eight-parameter write tool with no annotations and no output schema, one sentence is not enough. Key context such as required fields, side effects, and return behavior is left entirely to the schema and inference.

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 88% across eight parameters, so the schema already documents nearly every field. The description adds only the framing that the saved content is an AI prompt result, without elaborating on any parameter semantics beyond what the schema 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?

States a specific verb and resource ('Save an AI prompt result as a vault entry'), which clearly conveys the action and output. It does not differentiate from close siblings like save_entry, save_artifact, or vault_mem_save, so an agent cannot tell from the description alone which save tool to pick.

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

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

There is no when-to-use guidance, no prerequisites, and no mention of alternatives such as save_entry or save_artifact. The only implied usage comes from the phrase 'AI prompt result,' leaving the agent to infer the selection conditions.

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

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

No annotations are provided, so the description carries the full behavioral burden. It implies a read/search operation and mentions junction-table matching, but does not disclose result ordering, pagination behavior, permissions, or what the response looks like.

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 front-loaded sentence with no wasted wording. The only minor issue is the unexplained 'junction table' jargon, which adds little for an agent invoking the 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?

The schema fully documents the five parameters, which covers the core invocation details. However, with no annotations and no output schema, the description should say more about result behavior, ordering, and pagination for a search tool.

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

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

Schema description coverage is 100%, so all five parameters are already documented in the schema. The description adds the all/any matching concept but does not provide meaning beyond the schema's own 'all (intersection) or any (union)' explanation.

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

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

States a specific verb and resource: 'Search entries by tags'. It also clarifies the tag-matching mode ('all/any match'), but does not explicitly differentiate itself from sibling search tools such as search_entries.

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 the all/any matching behavior but gives no guidance on when to use this tool instead of search_entries or vault_mem_search. There are no stated exclusions, prerequisites, or alternative-selection cues.

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 and it does not. It names the search engine (FTS5) but says nothing about ranking, result shape, whether archived entries are excluded by default (implied only via the include_archived param name), cost of vector search, or pagination/limits 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?

One short clause with no wasted words, but it is under-specified rather than concise. The scarce space is spent on an implementation detail (FTS5) instead of disambiguation or default behavior.

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?

An 8-parameter, zero-required search tool with no annotations and no output schema needs far more than one clause: default matching mode, tag filter semantics (AND/OR), archived handling, and return format are all absent. The complexity of the tool is not matched by the description.

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 88%, so most parameters are self-documenting and baseline 3 applies. The description's only added semantic is that FTS5 is the default mode and the vector parameter switches engines, which is modest value 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 verb (search) and resource (entries) plus the mechanism (FTS5 with filters), which is more than tautology. But it never distinguishes itself from siblings like search_by_tags, vault_mem_search, or search_links, all of which also search entries by different means, so an agent cannot tell when this is the right search tool.

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 when-to-use guidance at all. The description does not explain relationship to search_by_tags (tag-only search) or vault_mem_search, nor does it say when to prefer FTS5 keyword matching versus the vector flag it exposes.

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

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

No annotations are provided, so the description carries the full behavioral burden. 'FTS5' is a genuine hint that the query is a full-text match expression rather than a substring, but nothing is said about result ordering/ranking, pagination behavior, or the returned record shape for a read tool with no output schema.

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

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

A single front-loaded sentence with no filler; the verb and mechanism lead. It is efficient, though arguably under-sized for a tool whose sibling set makes disambiguation the main risk.

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 annotations and no output schema, the description is the only place to learn about result ranking, default-limit semantics, and the instruction/snippet distinction, and it covers none of these. For a 3-parameter search tool in a crowded sibling set, this leaves meaningful gaps.

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

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

Schema description coverage is 100%, so limit, query, and project are already documented in the schema. The description adds only the 'FTS5' hint, which marginally informs how the required query string should be composed but does not clarify filter interaction (e.g., whether project narrows before or after FTS matching).

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

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

States a specific verb and resource ('Search instruction recipes and command snippets') and adds the retrieval mechanism (FTS5), so the agent knows this is full-text search over the instruction store. It does not name or differentiate itself from siblings like search_entries or list_instructions, so an agent must infer that the target corpus is instructions rather than general entries.

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 when-to-use guidance, no exclusions, and no alternatives. With siblings such as list_instructions, get_instruction, and search_entries present, an agent receives nothing about when full-text instruction search beats enumerating or fetching 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 present, the description must carry the whole burden. It usefully discloses that matching is full-text across four fields (so agents know partial-token matching applies), but says nothing about result ordering, pagination behavior, or that it is a non-mutating read. Partial coverage of a zero-annotation 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?

A single sentence with zero filler, and the resource plus search scope are front-loaded so an agent can decide immediately.

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 three-parameter, no-annotation, no-output-schema tool, the description covers purpose and query scope but leaves the result shape, ordering, and pagination unaddressed. Adequate but with clear gaps an agent would want filled.

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 already 100%, so the baseline is 3; the description earns more by explaining that the query matches title, summary, tags, and URL, which tells an agent how to phrase queries (e.g., tag names are searchable directly). Limit and project are left to 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 ('Search'), a specific resource ('stored URL bookmarks'), the mechanism (FTS5), and the searchable fields. This clearly distinguishes it from sibling list_links (enumerate) and search_by_tags (tag-only search) without needing to open schemas.

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

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

Usage is implied by the resource type (bookmarks vs. entries/instructions) and the FTS5 field scope, but the description never says when to prefer it over list_links, search_by_tags, or search_entries. No exclusions or alternatives are named.

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

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

No annotations are provided, so the description carries the full behavioral burden. It says the tool saves content but does not disclose whether saves overwrite or append, whether project scoping affects storage, what permissions are needed, or what is 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?

The description is a single, front-loaded sentence with no wasted words. It efficiently communicates the core payload categories without burying the main purpose.

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 six-parameter save tool with no annotations and no output schema, the description is incomplete. It omits project scoping, artifacts, requiredness, append/overwrite behavior, and return information that an agent would need to invoke it confidently.

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

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

Schema description coverage is only 33%, so the description must compensate. It adds useful meaning for decisions, pending items, and learnings, but does not explain the project or artifacts parameters, array item formats, or which fields are required in practice.

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: save a session summary, including decisions, pending items, and learnings. It is clear what the tool does, but it does not distinguish itself from sibling save tools such as save_handoff or save_entry.

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 this is for wrapping up a session, but it gives no explicit guidance on when to use it versus alternatives like save_handoff, save_entry, or save_result. There are no exclusions or contextual conditions.

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

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

No annotations are provided, so the description carries the full behavioral burden. It states that the tool builds a compact pack, but does not disclose whether it is read-only, what the pack contains, how large it may be, or what side effects, permissions, or response format to expect.

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 front-loaded sentence with no wasted wording. Its brevity is efficient, though it leaves important behavioral details unstated.

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 annotations and no output schema, the description should explain what the "memory context pack" includes and how the result is shaped. Instead it gives only a high-level purpose, leaving an agent unable to predict the output or distinguish this tool from related context-fetching siblings.

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

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

There is one parameter and schema description coverage is 100%, so the schema already documents "project" as a name or ID. The description adds no syntax, format, or fallback meaning beyond what the schema provides, which fits the baseline 3 for fully covered 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, "Build," and a clear resource, "compact agent-ready memory context pack," scoped to a project. It is understandable without opening the schema, but it does not distinguish itself from nearby siblings such as get_context_bundle or get_context.

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 on when to use this tool versus alternatives like get_context_bundle, get_context, or vault_mem_get. The phrase "for a project" implies a context, but the description provides no exclusions, prerequisites, or routing conditions.

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

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

No annotations are provided, so the description carries the full disclosure burden. It implies a read and says the response includes content and metadata, but never states what happens when the ID is unknown, whether both id and observation_id must agree, or anything about size/truncation of 'complete content'.

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

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

A single front-loaded sentence with no filler. It is efficient, though the terseness is part of why the usage and error behavior gaps exist.

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 2-parameter, no-annotation, no-output-schema retrieval tool, the description covers purpose and the existence of metadata in the return, but omits not-found behavior and how it relates to the other vault_mem_* tools, leaving an agent to guess on failure paths.

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 both parameters (id and its alias observation_id) are already documented. The description only echoes 'by ID' and adds no extra semantics such as which alias wins if both are supplied. Baseline 3 applies.

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

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

States a specific verb ('Get') and resource ('observation memory') plus scope ('complete content and metadata ... by ID'). It is distinguishable from vault_mem_search or vault_mem_timeline by its by-ID retrieval, but it never names those siblings explicitly.

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

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

The description gives no guidance on when to use this versus vault_mem_search, vault_mem_context, or vault_mem_timeline. An agent must infer that this is the direct-fetch path rather than the discovery path.

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?

Since there are no annotations, the description must carry the full burden. It effectively communicates critical behavioral traits—deduplication and topic indexing—which are key operational details not captured in the schema alone.

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 tool is summarized in a single, highly efficient sentence. Every word—including the technical terms like 'episodic' and 'indexing'—serves a distinct and essential purpose.

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 a high complexity (8 parameters, specific memory types, scopes), but the single sentence only provides a high-level overview. It fails to provide context for the interplay between complex fields like 'topic' vs 'topic_key' or the specific implications of 'deduplication'.

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 description coverage is 100%, meaning the schema handles all parameter definitions. The description does not add unique semantic meaning beyond listing the resource management functions.

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 specific language ('Save,' 'episodic observation memory') and explicitly states high-value features ('deduplication,' 'topic indexing'), clearly defining the resource and its unique capability.

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?

While the description defines what the tool saves, it offers no guidance on when to use `vault_mem_save` versus the many similar memory saving tools in the sibling list (e.g., `save_entry`, `save_artifact`). There are no 'when' or 'when not' criteria 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?

No annotations exist, so the description carries the burden. "Preview truncation" is a genuinely useful disclosure that results are abbreviated previews rather than full records, but nothing is said about permissions, read-only vs. mutating behavior, pagination beyond the schema's limit, or result ordering.

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

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

A single front-loaded sentence with no waste. However, the brevity is close to under-specification rather than tight editing.

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 six-parameter search tool with no annotations and no output schema, the description should say how results are returned, what truncation means in practice, and how it relates to sibling search tools. Only the truncation hint partially addresses return 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?

Schema coverage is 100%, so all six parameters are already documented in structured data, and the baseline is 3. The description adds only the word "filters" — no semantics for query matching, topic vs. topic_key aliasing, or type values.

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

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

States a specific verb ("Search") and resource ("observation memories"), plus two scope traits (preview truncation, filters). It does not distinguish itself from sibling search tools like search_entries, search_by_tags, or vault_mem_timeline, which an agent would need in order to pick correctly.

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

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

There is no statement of when to use this tool versus the many adjacent search/timeline/context siblings. No exclusions, no prerequisites, no scenario guidance — the agent must infer from the name 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?

No annotations are provided, so the description carries the full behavioral burden and it discloses almost nothing. It does not say the operation is read-only, how the before/after windows default or cap, what happens if the memory ID does not exist, or how the 'id' vs 'observation_id' alias is resolved when both are supplied.

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

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

A single front-loaded sentence with no filler, and the key concept (chronological context around an observation) leads. It is efficient, though its brevity contributes to the coverage gaps elsewhere.

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 zero annotations and no output schema, the description leaves out the return shape (what a 'timeline' entry looks like), default window behavior, and how the two ID fields interact. An agent could call it, but could not predict what it gets back or which ID field to trust.

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 five parameters including the before/after defaults and the alias note; the baseline of 3 applies. The description adds no additional meaning beyond the schema, and notably does not resolve the alias-precedence question.

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+resource combination ('Retrieve chronological context ... around a memory observation') that clearly signals a timeline/windowing read operation. It does not differentiate itself from the near-sibling vault_mem_context, which an agent could easily confuse with this tool, so it stops short of a 5.

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

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

There is no guidance on when to use this versus vault_mem_get (single observation) or vault_mem_context (broader context bundle). Nothing indicates prerequisites, or whether an observation ID must already exist. The agent must infer the selection rule entirely from the name.

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