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. 'Bounded' hints at limits, but the description doesn't explain what bounds are applied, what side effects exist (if any), or whether it's a read or mutation. It doesn't mention permissions, reversibility, or response structure. Minimal value beyond the tool name.

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 short sentence, which is concise. However, the second clause ('the MCP host decides how to use it') is not actionable for the agent and wastes the only available space. The key phrase is front-loaded, but the sentence lacks structure or elaboration.

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 19 parameters, no annotations, and only an opaque description, this is severely incomplete. The description does not explain what a 'secondary-context pack' is, how it relates to memory/skills, or what the output looks like. An agent cannot determine required inputs, constraints, or expected behavior. Even with an output schema, the description fails to provide minimal usage context.

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

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

Schema description coverage is 0%, and the description adds no parameter information. It does not explain what query, memory_id, max_items, or other 19 parameters control. The description completely fails to compensate for the missing schema documentation, making it impossible for an agent to correctly populate 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 states a specific verb ('Build') and a resource ('bounded secondary-context pack'), which is clear about the tool's primary function. However, it doesn't differentiate from sibling tools like memory.read or session.write; 'secondary-context' is jargon that may not be self-explanatory to an agent.

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

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

The description provides no guidance on when to use this tool versus alternatives. It says 'the MCP host decides how to use it,' which shifts responsibility away from the agent and offers no context about scenarios where this tool is appropriate. No exclusions or alternative mentions.

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 does add a useful contract, that the aggregate is closed and deterministic and that SQL is never accepted, which signals a safe, contained operation. However, it never states whether the tool is read-only, what limits exist, or how results are shaped, leaving significant behavioral gaps.

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

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

The description is short and contains no filler, and the 'arbitrary SQL is never accepted' qualifier is a real, front-loaded constraint. It loses a point because the phrase 'closed deterministic aggregate' is dense jargon and would benefit from one concrete elaboration or example.

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 15 parameters, 0% schema description coverage, and no annotations, a single sentence cannot possibly cover the operational semantics of intents, filters, grouping, and periods. The output schema explains return shape only, not when or how to combine parameters correctly.

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

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

Schema description coverage is 0% and the description explains none of the 15 parameters, from intent and field to group_by, period, and the various workspace/filter IDs. The agent is forced to infer semantics purely from parameter names and enum values, so the description adds no value here.

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

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

The description states that the tool runs a closed deterministic aggregate, which identifies it as a memory analytics operation and separates it from retrieval-style siblings like memory.read and memory.search. However, the wording 'closed deterministic aggregate' is jargon and doesn't concretely specify what statistics are produced or over which memory records.

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 memory.analyze rather than memory.read or memory.search, nor any context about when the analytics intents in the schema are relevant. The only usage constraint is negative (no arbitrary SQL), which does not help an agent decide between the sibling tools.

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

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

No annotations are provided, so the description carries the full burden of behavioral disclosure. The description mentions 'preserving canonical documents and revision history,' which implies the archive operation is non-destructive to those elements, but it doesn't clarify what happens to other aspects of the memory (e.g., is it still searchable? does it become read-only? Is there an unarchive operation?). It also gives no indication of side effects or irreversible changes, which is critical for an archive operation.

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

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

The description is a single, concise sentence that front-loads the core action ('Archive a memory') followed by a key qualifier ('preserving canonical documents and revision history'). It's efficient and to the point, with no redundant words. However, it could be more structured by adding a second sentence with usage guidance, but for its length it earns a high score.

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 a single required parameter and an output schema (which likely describes the result), the description covers the basic purpose well. However, as a mutation-like operation with no annotations, it lacks critical behavioral details (e.g., side effects, reversibility, how the archive differs from deletion). It's minimally complete for an agent to invoke with confidence, but leaves important questions unanswered.

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

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

The schema has 0% description coverage, so the description must compensate. It clearly explains the purpose of the single parameter (memory_id) by identifying the target as 'a memory.' It doesn't describe the format (UUID is in the schema) or provide additional semantic context, but since there's only one parameter, the description's mention of 'a memory' is sufficient to clarify what the ID refers to.

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 ('Archive') and a clear resource ('a memory'), and it distinguishes the action by specifying what is preserved ('canonical documents and revision history'). It clearly communicates the primary purpose, even though it doesn't explicitly compare to siblings like memory.propose or memory.delete (which isn't present). It's specific enough for an agent to understand the core intent.

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 a specific use case—archiving while preserving canonical data—but provides no explicit when-to-use or when-not-to-use guidance. It doesn't mention when to prefer this over alternatives like memory.propose (new memory) or memory.read (viewing). The phrase 'preserving canonical documents' hints that this is for archiving without destroying key data, but this is not explicit.

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

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

No annotations are provided, so the description carries the full burden of disclosing behavior. It does not state whether proposing mutates state, whether the memory is immediately active or pending approval, what side effects occur, or any authorization requirements. Mentioning Markdown and PostgreSQL metadata hints at persistence but does not explain the tool's behavioral contract.

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 short sentence with no redundant text, so it is concise in length. However, it is under-specified: terms like 'canonical' and 'PostgreSQL metadata' add jargon without explanation, and no structure organizes the information that would help an agent use the tool. This is under-specification rather than effective conciseness.

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

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

Despite the presence of an output schema, the tool has 12 input parameters, 3 required fields, two enums, and several nullable UUID context fields, all of which are left unexplained. The description gives no guidance on how to select memory_type, what sensitivity levels mean, or how the various IDs relate to the memory being proposed. The definition is far from complete for effective agent usage.

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

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

Schema description coverage is 0%, and the description adds no meaning to any of the 12 parameters. It does not explain title, content, memory_type, sensitivity, or the optional context IDs. Even though the schema contains enums and titles, the description leaves the agent without any guidance on how to populate these fields correctly.

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

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

The description names a specific verb ('Propose') and a resource ('a canonical memory'), so it is more than a tautology. However, 'canonical memory' is undefined, and the phrase 'backed by Markdown and PostgreSQL metadata' clarifies storage but not the actual operation. It does not explicitly contrast with memory.read, memory.search, or memory.archive, so an agent could not confidently distinguish it from siblings.

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 tool versus alternatives. It does not mention that this is for creating/proposing a new memory while memory.read and memory.search are for retrieval, nor does it state any conditions or exclusions. Usage context is only implicit in the tool name and one-line description.

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 behavioral burden. It communicates a read/non-mutating operation and names the storage source, but it does not disclose behavior for missing or invalid identifiers, or any caveats around 'canonical storage'. For a simple read tool this is adequate but minimal.

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

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

The description is a single sentence with no filler or repetition. The action and identifier mechanism are front-loaded, and every word contributes to the operational 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?

Given one required parameter, an output schema, and a simple read operation, the description covers the core context. It omits minor details such as what happens on a missing ID or how to route to search, but those do not block safe invocation of the 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?

The schema provides only name, type, and UUID format with zero description coverage. The description adds meaningful semantics by identifying memory_id as the 'identifier' that selects the canonical memory, which is the essential role of the only parameter. More detail about obtaining the identifier would be useful but is not necessary for a single obvious parameter.

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

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

The description states a specific verb ('Read'), resource ('memory'), source ('canonical storage'), and selection mechanism ('by its identifier'). This clearly distinguishes the tool from siblings like memory.search, which is query-driven, and memory.archive, which changes state.

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 its identifier' implies the intended use case: call this when you already have a memory_id. However, it does not explicitly route the agent to memory.search when the ID is unknown, nor does it state when memory.read is the wrong choice.

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 full burden. It does disclose two behavioral traits: results are 'concise' and it does not load full documents, signaling a lightweight, non-destructive search. But it leaves the meaning of 'candidate' ambiguous (possibly the MemoryStatus enum value) and does not disclose default filtering or sort behavior.

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

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

The description is a single front-loaded sentence with no waste; 'Find' leads with the action. It is efficient with the content it has. However, it is so terse that it borders on under-specification for a 16-parameter 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?

A 16-parameter search tool with no annotations, no parameter descriptions, and no usage guidance leaves invocation semantics largely to guesswork. The output schema covers return values, which is good, but an agent cannot know how filters compose, what relation_depth means, or what 'secondary-context' selects. The description is insufficient for reliable tool invocation.

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

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

Schema description coverage is 0% — all 16 parameters are undocumented — and the description mentions no parameters at all. Parameter names give some hints (limit, exact, user_id), but opaque parameters like relation_depth, minimum_importance, and memory_types go unexplained. With zero coverage and zero description compensation, this is a critical gap.

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

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

The description uses a specific verb ('Find'), a resource type ('secondary-context candidates'), and a distinguishing constraint ('without loading full documents'). This separates it from memory.read, which presumably loads full documents. However, 'secondary-context' is domain jargon that is never defined, slightly weakening clarity.

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 clause 'without loading full documents' implies this is for lightweight skimming rather than full retrieval, which hints at usage context. But it never names sibling alternatives (e.g., memory.read for full documents, memory.analyze for deeper analysis) or states explicit when-to-use/when-not-to-use conditions. Usage guidance is left to inference.

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

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

With no annotations provided, the description bears the full burden of behavioral disclosure. It does add one useful trait — content stays in lazy resources, signaling a low-cost listing operation. However, it does not disclose ordering, validity criteria, or failure behavior, leaving notable 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 zero filler. Every clause carries meaning, and the key verb 'List' appears first. No structural waste at all.

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 zero parameters, an output schema, and a low-complexity operation, the description is largely complete. The main omission is explaining what makes a persona pack 'valid' and how this relates to the sibling persona.validate tool, which would have made the context airtight.

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

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

The tool has zero parameters and the schema has no properties, so the baseline of 4 applies. There is no parameter meaning the description needs to add.

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

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

The description uses a specific verb and resource — 'List valid persona packs' — making the primary action unambiguous. The behavior note about lazy resources adds differentiation, though it does not explicitly distinguish from sibling tools like persona.validate or skill.list.

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

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

No guidance is given on when to use this tool over alternatives; no exclusions or sibling references are mentioned. An agent cannot tell whether to call persona.list before persona.validate or how they relate, despite persona.validate being an obvious sibling.

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 full behavioral burdenasia it only says 'Return actionable diagnostics' and does not disclose whether validation is read-only, whether it checks syntax/semantics/deployment, or how failures are reported. This is minimal behavioral transparency.

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 communicates the core action and object economically, though it does sacrifice some contextual detail.

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 validation tool with an output schema, the description is minimally viable but lacks usage context, parameter semantics, and behavioral assurances. It is complete enough for a simple call, but not for confident routing or edge-case handling.

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

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

The schema has 0% description coverage and one optional persona_id parameter, but the description adds no parameter-level guidance. The agent must infer that persona_id scopes validation, and the meaning of a null default is left ambiguous.

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

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

The description clearly names a specific verb ('Return') and resource ('actionable diagnostics for declarative persona packs'). It implies validation of persona definitions)Skip comparing to siblings like skill.validate, but does not explicitly name them or distinguish itself.

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

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

No guidance is provided about when to use this tool versus alternatives such as skill.validate or persona.list. There are no exclusions, prerequisites, or typical use-case context, leaving the agent to infer suitability.

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

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

With no annotations, the description carries the behavioral burden. It usefully discloses that results are concise metadata and that full entries are reachable via resource URI. However, it does not disclose default limit, pagination behavior, filter semantics, or explicit side-effect-free guarantees beyond the implied read-only nature of 'List'.

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

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

Two short, front-loaded sentences: the purpose comes first and the full-entry resolution path second. There is no filler, repetition, or unnecessary detail.

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 six optional parameters and no annotations, the description is too sparse. It omits filter semantics, default behavior, and any guidance about combining or leaving filters empty. The output schema helps document return values, but the missing parameter context and usage caveats leave an agent guessing.

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?

All six parameters are optional and have no schema descriptions, so the description must compensate for 0% schema coverage. It does not mention any parameter or explain that user_id, tenant_id, etc. are filtering scopes or that limit controls page size. The description adds no meaning beyond the parameter names.

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 an explicit verb ('List') and identifies the resource ('session') with a scope qualifier ('concise session metadata'). By stating that full entries are obtained separately through the resource URI, it clearly distinguishes listing from full-content access and from the sibling write tool session.write.

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 implicitly guides the agent to use this tool for metadata browsing rather than full-content retrieval, pointing to the resource URI for full entries. It does not explicitly name sibling tools or state when not to use filters, but the core when-to-use decision is conveyed.

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 of behavioral disclosure. The verb 'persist' implies mutation, but nothing is said about side effects, idempotency (despite an idempotency_key parameter), overwrite semantics, or return behavior. The description offers only minimal context beyond the name.

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 short sentence with no fluff, which is structurally concise. However, it is so sparse that it borders on under-specification rather than effective conciseness. It is not front-loaded with the most important information because it contains almost no 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?

Given 10 parameters, an enum for entry types, and an output schema, the description is grossly incomplete. It does not explain what entries are, how client relates to sessions, or what the timestamps and IDs mean. An agent cannot confidently invoke this tool without external knowledge.

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

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

Schema description coverage is 0%, so the description must explain parameters, but it mentions none of the 10 parameters (client, entries, user_id, etc.). The schema itself has no descriptions, so the agent gets no meaning beyond field names and types. The description adds zero value here.

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

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

The description states a clear verb ('persist') and a resource ('structured context'), but 'structured context' is vague and doesn't convey the specific types of entries (summary, decision, fact, etc.) that the schema defines. It does not differentiate from sibling tools beyond implying a write operation, so an agent cannot fully understand the tool's role from the description alone.

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 memory.write or memory.propose. No conditions, prerequisites, or exclusions are mentioned, leaving the agent to infer usage from the schema and sibling names, which is insufficient.

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

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

There are no annotations, so the description carries the full behavioral burden, but it only mentions a 'persistent status overlay' without explaining consequences, reversibility, permissions, or effects on other operations. The implied persistence is useful, but important behavioral details are missing.

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

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

The description is a single concise sentence with no filler, and the core action is front-loaded. The vague 'persistent status overlay' clause costs some clarity, but overall the length 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?

An output schema exists, so return-value documentation is not necessary, but the description omits parameter meanings, usage conditions, and any warning about the mutation's persistence. For a tool with no annotations, this leaves an agent under-equipped 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 description coverage is 0%, and the description provides no explanation of the skill_id or version parameters. The phrase 'validated skill version' hints at version semantics, but it does not clarify the meaning of the optional version parameter, default null behavior, or required identifier format.

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 ('Disable') and identifies a resource ('a validated skill version'), which clearly differentiates it from sibling tools like skill.enable. However, the phrase 'through the persistent status overlay' is opaque and adds ambiguity rather than clarity.

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

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

No guidance is given about when to use this tool versus alternatives such as skill.enable or skill.validate. The phrase 'validated skill version' implies a prerequisite, but there is no explicit statement about when disabling is appropriate.

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 carries the full burden of behavioral disclosure. It mentions a 'persistent status overlay,' implying the change is durable, but it does not disclose whether enabling replaces other versions, requires permissions, or has side effects.

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

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

The description is a single, front-loaded sentence with no filler. It is appropriately terse, though the unexplained 'persistent status overlay' makes it somewhat cryptic.

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 operation with an output schema and no annotations, the description is thin. It omits lifecycle prerequisites, default behavior for version, and the meaning of 'persistent status overlay,' leaving an agent to infer important call semantics.

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

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

Schema description coverage is 0%, and the description adds no explanation of skill_id or the optional version parameter. Crucially, it does not clarify what happens when version is omitted, how version selection works, or any constraints related to validated versions.

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 concrete action ('Enable') and a specific target ('a validated skill version'), which separates it from sibling operations like skill.validate and skill.disable. However, the phrase 'persistent status overlay' is unexplained jargon that slightly muddies the core meaning.

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

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

No guidance is provided about when to use this tool versus alternatives such as skill.validate or skill.disable. The word 'validated' hints at a prerequisite but does not explicitly state sequencing, lifecycle context, or when this should be preferred over other skill tools.

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

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

No annotations are provided, so the description carries the full burden. It discloses one trait: 'instructions remain a lazy resource' – suggesting the metadata returned does not eagerly include instruction content. However, it does not state whether the operation is read-only, requires permissions, or has side effects. The word 'resolve' hints at some computation, but the overall behavior is under-specified.

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 conveys the core action and a key behavioral nuance. It is concise, but arguably too terse given the lack of annotations and parameter coverage.

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 an output schema, so return values are covered, but the description still lacks necessary context for correct invocation. It does not state prerequisites (e.g., must the skill exist?), error behavior, or when to prefer this over sibling tools. For a simple get with no annotations, the description leaves significant gaps in usage context.

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

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

Schema coverage is 0%, so the description must compensate. The phrase 'exact or latest' adds meaning to the optional 'version' parameter (exact when specified, latest when null). However, it offers nothing about 'skill_id' beyond what the schema already labels as 'Skill Id'. This is a partial compensation – the version semantics are helpful, but skill_id is left to inference.

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 the tool resolves skill metadata, distinguishing it from skill.list (which lists) and skill.validate/enable/disable (which modify or check). 'Resolve' is a bit abstract but combined with 'exact or latest skill metadata' the core action is clear. It doesn't explicitly contrast with siblings but the name and context imply a single-item retrieval.

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

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

No guidance is given on when to use this tool versus alternatives. The description does not mention skill.list for enumerating skills or skill.validate for checking validity. The only hint is 'exact or latest' which implies version selection, but there is no explicit 'use this when...' or 'use skill.list for...'.

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

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

With no annotations provided, the description must carry behavioral disclosure. It does reveal that it doesn't load full instructions (a useful non-obvious behavior), but it doesn't mention whether it lists system skills, the effect of the parameters (e.g., including disabled versions), or if any authorization is needed. It's adequate but not rich.

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, front-loaded with the main action and key detail (validation and no full loading). No wasted words — every phrase adds value.

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

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

Given the tool's simplicity (two optional booleans) and the presence of an output schema, the description is mostly sufficient. However, it lacks explicit guidance on the two parameters and potential filtering semantics, making it functionally complete but not fully comprehensive for an agent deciding between list and get.

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

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

The schema has 0% description coverage, so the description must compensate for the two boolean parameters. Although it does not explicitly explain all_versions or include_disabled, the parameters are booleans with self-explanatory names, and the default of false is visible. The description adds context that listing is lightweight, which helps the agent infer parameter purpose.

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

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

The description states a clear verb ('List') and resource ('validated declarative skills'), and adds a behavioral detail — it does not load full instructions, distinguishing it from skill.get. This clearly differentiates the tool from its siblings (skill.get, skill.validate, etc.).

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

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

The description implies usage — it lists skills without loading full instructions, so an agent knows it's a lightweight listing tool. However, it does not explicitly state when to use this vs. skill.get, nor does it mention the all_versions and include_disabled parameters as optional filters.

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. 'Return actionable diagnostics' hints at a read-only validation behavior, but it does not disclose side effects, error conditions, authentication requirements, or what makes the diagnostics 'actionable.' The description adds little beyond the obvious implication of the tool name.

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 or repetition. Every word contributes to the stated purpose, making it highly concise even though other dimensions lack depth.

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 is low-complexity and has an output schema, but the definition is still incomplete for invocation: it lacks parameter semantics, usage context, and behavioral detail. An agent would not know what value to pass for skill_id or when this tool is the correct choice.

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

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

The schema has one parameter, skill_id, with 0% description coverage, and the description never mentions how to identify the skill package to validate. It does not explain whether skill_id is required, how null behaves, or what happens when it is omitted, leaving the agent to guess from the property title alone.

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

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

The description states a specific action ('Return') and resource ('diagnostics for declarative skill packages'), moving beyond the tool name. It differentiates this from sibling read/manipulation tools like skill.get and skill.list by focusing on diagnostics, though it doesn't explicitly say 'validates'.

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 over skill.list, skill.get, or persona.validate. The phrase 'for declarative skill packages' loosely implies scope, but there is no explanation of prerequisites, exclusions, or when an agent should choose an alternative.

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