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

Annotations already mark the tool with readOnlyHint=false and idempotentHint=false, but the description adds no behavioral detail about what that implies—such as side effects, influence tracking, or whether the request is recorded. The phrase 'Get' sounds read-only and is not strongly reconciled with readOnlyHint=false, and no meaningful behavioral context is disclosed beyond what the annotations provide.

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, focused sentence that states purpose in minimal words and includes no fluff. It puts the essential action first and contains no excessive detail, making the verb-resource-input structure easy to parse quickly.

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

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

Although an output schema exists and parameters are fully documented in the schema, the description omits usage context such as recommending when to call this tool, the requirements (e.g., active constitutions or persona availability), and side-effect semantics. For a decision-making tool with a non-readonly annotation, that missing context is material.

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 input schema already documents context, question, and persona_id well. The description's mention of 'active constitutions and persona' does add slight semantic mapping to the context.constitutions and persona_id parameters, but it does not enrich individual parameter meaning beyond that. With full schema coverage, baseline 3 is appropriate.

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

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

The description names a specific verb ('Get'), a resource ('policy decision kernel'), and the input basis ('for a user request based on active constitutions and persona'). This clearly identifies the tool's function and generally separates it from sibling retrieval tools like get_constitution or list_personas, though the phrase 'decision kernel' is somewhat jargon-heavy and not immediately 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 does not state when to use adjudicate versus alternative tools, nor does it provide any exclusion or routing guidance. It merely describes what the tool does, leaving an agent to infer that it should be used when a policy decision is needed. Given the many sibling tools, explicit usage conditions would be valuable.

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

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

The readOnlyHint annotation indicates no side effects, but the description does not explain what happens when a violation is found or how the attestation result is returned. The exact behavioral outcome (e.g., boolean, error, report) is not disclosed.

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

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

The description is a single, concise sentence that introduces the tool's purpose without unnecessary details or redundancy. It is well-structured and easy to parse.

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?

While the tool has an output schema (per context signals), it is not included in the description itself, leaving the agent without knowledge of what the tool returns. Additionally, the description does not mention any potential side effects or state changes beyond the readOnlyHint annotation.

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

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

Both parameters are described in the schema, and the coverage is 100%. However, the description does not add context beyond the schema definitions—for example, it does not clarify what constitutes a valid 'response' or how 'persona_id' affects validation.

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 (validate) and the target (response against the active creed). However, it does not distinguish itself from sibling tools like 'adjudicate' or 'perform_multi_scale_handshake,' which could lead to confusion about when to use this specific 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?

The description implies usage for checking attestation but does not explicitly state when to prefer this tool over alternatives. No guidance is given about prerequisites or scenarios where other tools (e.g., 'adjudicate' or 'get_scale_attestation') would be more 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?

The description explicitly discloses the mutation (clearing the cache) and the resulting behavior (forcing fresh data). It does not mention potential side effects, but since the annotation indicates destructiveHint is false, the operation is expected to be safe and reversible. This provides adequate 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?

The description is extremely concise, using a single sentence to convey the action, target, and purpose. No unnecessary words or repetition. It is well-structured for quick comprehension.

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 simplicity of the tool (no parameters, no complex behavior), the description provides all necessary information for an agent to understand and invoke it correctly. The effect on data freshness is clearly stated, making the context complete.

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

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

The tool has no parameters, and the schema coverage is 100% (empty schema). There is nothing to document, so the description fully covers the parameter space. A perfect score is appropriate.

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

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

The description clearly states the tool's function: clearing the local cache to force fresh data. It uses a specific verb ('Clear') and identifies the resource ('local cache') and the intended effect ('force fresh data from the API'). This is unambiguous and distinguishes it from 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?

The description implies when to use the tool (whenever a refresh of data is needed) but does not explicitly contrast it with alternatives. However, among the listed sibling tools, none serve a similar purpose, so the guidance is sufficient for correct selection.

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

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

Annotations already indicate read-only, and description adds no extra behavioral details; it's a simple getter.

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?

Single concise sentence with no filler.

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

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

Given no parameters, no output schema, and a clear purpose, the description is sufficient; it doesn't need to explain more.

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?

No parameters, so schema fully covers; description adds nothing extra, but that's fine per 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?

Clearly states it retrieves the active persona, distinguishing from list_personas (listing all) and set_persona (setting).

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

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

Provides no explicit guidance on when to prefer it over siblings, but the name and purpose make it obvious for fetching the current persona.

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

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

Annotations already indicate this is a read-only, open-world operation. The description adds non-redundant context by specifying the output compactness (1-2KB), the content (top 10 rules, creed hash, and how this serves quick reinforcement). No contradictions with annotations.

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

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

The description is a single, tightly-written sentence that front-loads the core action ('Get a compact anchor') and immediately conveys its size and content, with no 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?

With only 2 optional parameters, comprehensive schema descriptions, an output schema, and annotations covering read-only / open-world, the description completes the main context. It explains the output's purpose but could be slightly more explicit about when to choose it over get_constitution or get_system_prompt.

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 descriptions already exist for max_length and persona_id. The tool description does not need to add parameter-specific meaning; it kept the baseline of 3, meaning no extra value beyond schema is offered.

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 identifies the verb ('Get'), resource ('anchor'), and specific includes (top 10 non-negotiable rules and creed hash). It communicates the compact nature and the purpose, though it does not explicitly compare to sibling tools like get_constitution or get_system_prompt.

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 clearly provides a usage context ('for quick context reinforcement'), which implies when an agent might want this instead of a full document. However, it does not explicit delimit alternatives or state when not to use it, so it does not reach a 5.

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

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

The read-only nature is already indicated by the readOnlyHint annotation, so no additional side-effect disclosure is needed. The description adds transparency about the returned content (all active rules and UVC qualities), which helps set expectations.

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 conveys the essential purpose without redundancy. It is well-structured and directly states the tool's function and content 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?

Given the tool's simplicity and the presence of an output schema (not detailed here), the description does not need to explain return values. It sufficiently covers the input and purpose, though it does not mention potential errors or edge cases, which is minor given the 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?

The single parameter persona_id is fully described in the schema (including default and examples), achieving 100% coverage. The tool description does not add supplementary meaning beyond the schema, 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 clearly states the tool retrieves a merged constitution for a specific persona, including active rules and UVC qualities. It uses a specific verb ('Get') and identifies the resource ('merged constitution') and scope ('for a specific persona'), effectively distinguishing it from tools like get_constitution_by_id.

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 via 'for a specific persona' and the persona_id parameter, but does not explicitly contrast with alternatives such as get_constitution_by_id or list_personas. No explicit guidance on when to prefer this tool over others is provided.

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

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

The readOnlyHint annotation already indicates this is a read-only operation, and the description aligns with that by using the verb 'Get'. No side effects are mentioned, and there is no contradiction between the description and annotations.

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

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

The description is a single, concise sentence that directly states the tool's purpose without unnecessary elaboration or redundancy.

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

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

Given the existence of a sibling tool 'get_constitution', the description does not clarify the difference, leaving the agent uncertain about which tool to invoke. Additionally, there is no output schema or description of the return value, which could be important for 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?

The single parameter 'constitution_id' is clearly described as 'The constitution ID', which matches the schema. The description fully covers the parameter's meaning, though it adds minimal extra context beyond the name.

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

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

The description clearly states the action (get) and resource (a specific constitution by ID). However, it does not differentiate from the sibling tool 'get_constitution', which likely has a similar purpose, creating ambiguity about the exact distinction.

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 on when to use this tool versus the sibling 'get_constitution'. The description implies it is for fetching a constitution by ID, but does not explicitly state the alternative or the conditions for choosing this tool over another.

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

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

The description mentions the hash chain inclusion, adding useful info about the response. With readOnlyHint true, there is no contradiction and no hidden 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?

Single concise sentence that immediately conveys the tool's core purpose without 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?

The description is sufficient for understanding the tool's function given the output schema exists. It doesn't need to elaborate on return format, but the mention of hash chain provides 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 descriptions cover the parameters adequately. The description adds minimal extra meaning beyond restating 'scale and entity', so baseline of 3 is appropriate.

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

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

The description clearly states the action (get), the resource (attestation record), and specific scoping (by scale and entity). It is distinct from sibling tools like 'attest_response' and 'get_anchor'.

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

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

The description implies usage for retrieving attestation records by scale and entity, but does not explicitly mention when to choose this over alternatives or provide any usage 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?

Annotations already indicate readOnlyHint=true, so no side-effect disclosure is needed. The description adds useful context about the content of the returned prompt (includes constitution and UVC qualities), going beyond the annotation.

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 unnecessary words. It efficiently conveys the purpose and content of 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?

For a simple get operation with no output schema, the description provides enough context. It does not mention error cases or how to discover personas, but given the sibling tools (e.g., list_personas), an agent can infer the workflow. The absence of an output schema means no need to document return values.

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 single parameter 'persona_id' is documented in the schema with a default value. The tool description relates the parameter to 'a persona,' and the schema provides a basic description. This is sufficient for correct usage, though it could benefit from listing valid persona IDs or linking to a listing tool.

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

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

The description clearly states the action ('Get'), the resource ('system prompt for a persona'), and the scope (includes constitution and UVC qualities). It distinguishes itself from sibling tools like get_constitution or get_uvc_qualities by indicating it retrieves the full combined prompt.

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

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

The description implies when to use this tool (when a complete system prompt is needed) but does not explicitly mention alternatives or when not to use it. The meaning is clear enough for an agent to infer, but a direct comparison with siblings would improve guidance.

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

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

Annotations already declare readOnlyHint=true and openWorldHint=true, covering the safety profile. The description adds no behavioral details beyond stating it retrieves qualities, such as error handling, default persona behavior, or limits. It is consistent with annotations but provides minimal added 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?

The description is a single sentence that front-loads the action and resource. It contains no filler and is appropriately sized for a simple getter 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?

Given the tool has only one optional parameter and an output schema (which covers return structure), the description is sufficient for basic invocation. It does not address edge cases or alternative usage, but for a simple read-only getter the descriptions covers the essential 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 100% and the parameter 'persona_id' is already described as 'The persona ID' with a default. The description adds no extra meaning or constraints beyond what the schema provides, so the baseline of 3 applies.

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

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

The description clearly states the verb 'Get' and specifies the resource as 'desired, disliked, and never qualities for a persona from the UVC system'. It is specific enough to distinguish from sibling tools like get_constitution or get_system_prompt, which target different resources.

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

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

The description provides no guidance on when to use this tool versus alternatives. It does not mention any context for selection, such as comparing to other getters or explaining that it is the only way to retrieve persona qualities. The agent has to infer usage from the name and schema alone.

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

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

Annotations declare readOnlyHint=true and openWorldHint=true, so the agent already knows this is a safe, read-only operation. The description adds that it returns a mini-anchor and the frequency, which is useful context. However, it does not disclose any further behavioral details like dependencies on session state or how force modifies behavior. It does not contradict annotations.

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

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

The description is a single sentence, concise and front-loaded with the primary purpose. It is easy to scan and contains no filler. However, it is slightly too brief to capture all necessary usage nuances, but for conciseness it is effective.

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 3 optional parameters and an output schema. The description does not clarify when to use force, how message_count interacts with the 'every 10 messages' rule, or how this tool relates to get_anchor. It lacks guidance on prerequisites or conditions for invocation. Given the complexity (multiple params and siblings), the description is incomplete for an agent to decide when to call it correctly.

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

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

Schema coverage is 100% with each parameter having a description, so the baseline for high coverage is 3. The description adds minimal value beyond the schema: it mentions 'every 10 messages' which relates to message_count, but does not explain the purpose of force or persona_id. It does not compensate or enrich the parameter meanings beyond what the schema already provides.

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

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

The description clearly states that the tool performs periodic re-anchoring to prevent context drift and returns a mini-anchor every 10 messages. It has a specific verb and resource, and the frequency is mentioned. However, it does not explicitly differentiate from siblings like get_anchor, which might also provide anchors, so it is not fully distinct.

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

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

The description implies periodic usage ('every 10 messages') but does not explicitly state when to use this tool versus alternatives such as get_anchor. It does not connect the message_count parameter to the condition, nor does it explain when to use the force parameter. No exclusions or alternative scenarios are provided.

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

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

The annotations already declare readOnlyHint=true and openWorldHint=true, which covers safety and scope. The description adds that results will include descriptions and current status, which is mild value beyond the annotations. It does not discuss pagination, order, or response structure, but for a simple read-only list with annotations this is acceptable.

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

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

A single sentence, 'List all available AI personas with their descriptions and current status', with no filler. It front-loads the action and resource, giving the essential information instantly.

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 this is a 0-parameter read-only list with an output schema present, the description is complete: it specifies what is listed and what fields appear. It does not need to explain return values because the output schema already provides that. A minor lack is no mention of pagination/order, but that is not required for a simple listing with an output schema.

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

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

There are zero parameters, so the input schema is fully covered at 100% and there are no parameter semantics for the description to clarify. Per the rubric, a tool with no parameters earns a baseline 4; the description exposes the list's content rather than adding parameter behavior.

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: 'List all available AI personas' with an extra detail on what the listing includes ('descriptions and current status'). It is clearly distinguished from siblings like set_persona (mutating) and get_active_persona (single item) by the 'all available' phrasing.

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 rather than explicit: 'List all available AI personas' conveys this is for enumeration, and the sibling set shows alternatives like get_active_persona, but the description does not explicitly say when to prefer this over those or include any when-not-to-use guidance.

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

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

Annotations already declare readOnlyHint=false, idempotentHint=false, and destructiveHint=false, so the safety profile is partially covered. The description adds behavioral context like 'anti-collusion and hierarchical budgets', but does not explain what side effects occur, what happens on failure, or whether any state is mutated. This is acceptable given the annotations cover the basics, but more detail would improve 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?

The description is a single sentence with no filler, front-loading the core action. It is efficient and well-structured. However, it is so brief that it borders on under-specification, which is a slight deduction from a perfect 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?

For a tool with nested party objects and invariants, the description is severely underspecified. It does not explain what a 'handshake' entails, how invariants are enforced, what constitutes success, or what the output looks like (though an output schema exists). Given the complexity of multi-party, multi-scale operation, the description is inadequate for an agent to invoke it correctly without additional 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 100%, meaning all parameters (parties, invariants) have descriptions in the schema. The description itself does not add detailed parameter semantics, but it does imply the handshake operates on multiple parties and scales, which aligns with the schema. Since the schema already carries the burden, a baseline of 3 is appropriate.

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

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

The description states a specific action ('Perform N-party value handshake') with clear scope ('across micro/meso/macro scales') and adds distinctive elements ('anti-collusion and hierarchical budgets'). It is not a tautology and distinguishes from siblings like 'adjudicate' which is a different operation. However, the term 'handshake' is not elaborated, leaving some ambiguity about the exact operation.

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 on when to use this tool versus alternatives. Siblings such as 'adjudicate' or 'attest_response' might be related, but the description does not mention them or any conditions that would select this tool over others. 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?

The description says 'Preview', which strongly implies a read-only operation, but the annotation readOnlyHint is false, indicating the tool may have side effects. This is a direct contradiction that could mislead an agent about the tool's safety. No additional behavioral details are provided to clarify what side effects might occur.

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 directly states the tool's purpose. It is well-structured and free of unnecessary detail, making it easy for an agent to parse quickly.

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

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

The description is minimal and lacks information about the expected output format, side effects, or when to prefer this over sibling tools. The read-only contradiction further undermines context, leaving an agent with insufficient guidance for safe and correct 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?

The schema provides descriptions for all four parameters (persona_id, include_uvc, include_constitutions, include_system_prompt), covering 100% of them. The tool description itself adds no further elaboration on the parameters, so the schema carries the semantic weight. This is adequate but not enhanced by the description.

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

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

The description clearly states the tool previews export configuration for Claude Code or other AI tools, using a specific verb ('Preview') and resource ('export configuration'). It is distinguishable from sibling tools that fetch individual components like constitutions or system prompts, though it does not explicitly name them.

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, nor does it mention any prerequisites or typical scenarios. An agent would have to infer that previewing is appropriate when planning an export, but no explicit direction is given.

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

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

Annotations declare readOnlyHint=true and openWorld=true, so the safe, non-destructive nature is covered. The description adds no behavioral detail beyond that, but the annotation coverage is sufficient.

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 redundancy. It front-loads the action and resource, making it easy to parse.

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 search tool, the description is adequate. An output schema exists but is not described; however, the search intent is clear, and no complex side effects or edge cases are relevant.

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?

Both parameters have concise, meaningful descriptions in the schema ('Search query' and 'Filter by persona ID'). Schema coverage is 100%, and the values align with the stated search scope.

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?

Clearly states the verb 'Search' and the resource 'constitutions', with scope 'by keyword or persona'. This distinguishes it from sibling tools like get_constitution which fetches a specific document.

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

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

The description implies use for keyword/persona-based searches but does not explicitly state when to prefer this over alternatives such as get_constitution or list_personas. No explicit when/when-not guidance is given.

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

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

Annotations indicate readOnlyHint=false, idempotentHint=true, and destructiveHint=false, which already convey key behavioral traits. The description adds only that the change applies to the current session, but does not mention potential side effects, permissions, or state persistence beyond that.

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

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

The description is a single, concise sentence with no redundancy or unnecessary detail. It is well-structured and easy to parse.

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

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

The description is sufficient for a simple setter operation and provides the scope ('current session'). However, it does not mention error handling, return values, or behavior when an invalid persona_id is provided, which could be helpful in a more complex 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?

The schema provides a description for persona_id ('The persona ID to switch to') and an enum list, giving 100% coverage. The main description does not add semantic detail beyond what is already in the parameter description, so the added value is minimal.

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

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

The description clearly states the action ('Switch'), the resource ('AI persona'), and the scope ('for the current session'). It distinguishes the tool from sibling read-only tools like get_active_persona or list_personas.

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 tool is for changing the persona rather than querying it, but it does not explicitly state when to use or when not to use it compared to alternatives. The 'different' wording hints at a change operation but lacks explicit guidance.

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