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 discloses that the tool selects a preset, returns encoding instructions, and provides concrete performance metrics for each preset. It does not explicitly state whether the operation is stateless or has side effects, but the 'return encoding instructions' phrasing implies a non-mutating compute 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?

Two sentences with no filler. The first sentence front-loads the core purpose and selection logic; the second provides useful preset benchmarks. Every sentence earns its place.

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

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

Given no output schema and no annotations, the description covers the main needs: what the tool does, what inputs influence it, and what general result to expect. The return format is only described as 'encoding instructions,' which is somewhat vague, but the preset table and selection logic are enough for an agent to invoke the tool 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 100%, so the schema already documents all parameters. The description adds value by explaining the relationship between fragment_type/context_pressure and transformer selection, and by naming the available presets with compression and quality stats. It doesn't discuss preset_override, but the schema covers that parameter's role.

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 action: automatically select the optimal transformer and return encoding instructions. It distinguishes itself from manual transform tools like wisdom_transform_to_fragment and wisdom_transform_from_fragment by emphasizing automatic selection based on fragment_type and context_pressure.

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 clear context for when to use the tool: when automatic transformer selection is desired based on fragment type and context pressure. It does not explicitly name alternatives or state when not to use it, but the 'automatically select' framing makes the intended use case reasonably clear.

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

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

With no annotations, the description carries the full burden of behavioral disclosure, but it only offers a terse one-line purpose. The word 'placeholder' suggests the tool may not actually perform a real trust calculation, yet this is not elaborated. No mention is made of side effects, required preconditions, return behavior, or failure modes.

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

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

The description is a single concise sentence with the key action front-loaded. The parenthetical 'placeholder for trust-path calculation' adds a useful qualifier about implementation status without bloating the text. It could add a bit more structure, but it is efficient for its length.

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

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

This is a relatively specialized calculation tool with no output schema and no annotations, yet the description provides almost no operational context. It doesn't explain what inputs beyond entity/perspective affect the result, what data the calculation depends on, or what the output looks like. The 'placeholder' status also leaves the agent uncertain whether calling this tool will return a meaningful result.

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

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

Schema description coverage is 100%, so the schema already documents both parameters adequately. The description adds little beyond confirming that the calculation is entity-focused and trust-related. Since the schema does the heavy lifting, a baseline score of 3 is appropriate.

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

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

The description uses a clear verb-resource pair: 'Calculate effective trust for an entity'. It also hints at the underlying mechanism with 'trust-path calculation', which helps distinguish it from sibling tools like wisdom_trust_agent. However, it doesn't explicitly contrast it with any sibling, so it falls short of full differentiation.

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

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

There is no explicit guidance about when to use this tool versus alternatives such as wisdom_trust_agent. The 'placeholder' note weakly implies it may not be production-ready, but no context, prerequisites, or exclusions are given. An agent would have to infer usage from the name and schema.

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 responsibility for behavioral disclosure. It only states that the tool checks integrity, but does not explain what integrity means, whether the operation is read-only, what the return value looks like, or how max_depth affects traversal. This is insufficient for an agent to predict 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 one front-loaded sentence with no filler or redundancy. It loses one point because it omits meaningful behavioral context, but as a concise statement it is well-structured.

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

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

For a tool with no annotations and no output schema, this description is too sparse. It does not clarify what 'integrity' means, what a positive or negative result looks like, or how deep traversal works. An agent would struggle to know whether the output is a boolean, a list of issues, or a thrown error.

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

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

Schema description coverage is 100%, so the schema already documents fragment_id and max_depth. The description adds only the DERIVED_FROM relationship context, which is marginal beyond the tool name. A baseline of 3 is appropriate because the schema does the heavy lifting.

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

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

Description uses a specific verb ('Check') and a specific resource ('integrity of a derivation chain (DERIVED_FROM relations) for a fragment'), which clearly differentiates it from simple retrieval tools like wisdom_get_relations. It could more precisely define what 'integrity' means, but the action and target are clear.

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

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

No guidance is provided about when to use this tool versus siblings such as wisdom_get_relations or wisdom_find_contradictions. The intended usage is only implied by the word 'Check', with no exclusions, prerequisites, or alternative routing.

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 explaining side effects. It only says 'clear,' which implies a destructive or state-resetting operation, but does not disclose whether project data is deleted, whether the action is reversible, what happens to persisted context, or whether confirmation is needed.

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 and wastes no words. It is concise, though the brevity comes at the cost of necessary behavioral 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?

This is a potentially state-changing tool with no annotations, no output schema, and a vague description. An agent cannot safely invoke it without knowing what 'clear' affects, what 'context' means here, what happens if persist=false, and how it interacts with project-related siblings.

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

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

Schema description coverage is 100%, so the parameter 'persist' is already documented in the schema. The tool description adds no additional meaning about the parameter and does not explain its effect on 'project context' in concrete terms.

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 verb ('Clear') and a resource ('current project context'), so it is not a tautology. However, 'current project context' is vague: it is unclear whether this means resetting an in-memory working set, deleting project data, or clearing a selection, and it does not distinguish the behavior from related siblings like wisdom_set_project or wisdom_load_context_for_task.

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 wisdom_set_project, wisdom_load_context_for_task, or wisdom_get_project. No conditions, prerequisites, or exclusion criteria are provided, leaving the agent to guess when clearing 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?

No annotations are provided, so the description carries the full burden of behavioral disclosure, but it only implies mutation via the word Update. It does not state whether changes persist immediately, whether a reload via wisdom_reload_config is required afterward, or what happens when the tool is invoked with zero optional parameters.

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, front-loaded with the action verb and free of filler. However, it is under-sized for a configuration mutation with subtle semantics around persistence scope and reload coupling, so the brevity reads more as under-specification than disciplined concision.

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 five optional parameters, no output schema, and no annotations, the description leaves critical gaps: the persistence model implied by save_to, the relationship to wisdom_reload_config, and the behavior when no arguments are passed. An agent cannot fully predict the effect of calling this tool from the description alone.

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

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

Schema description coverage is 100%, so the schema already documents every parameter, including the save_to enum, the gateway_url example, and the UUID lists. The description adds no parameter-level meaning beyond labeling the whole set as configuration, so the baseline of 3 applies.

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

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

The description uses a specific verb ('Update') and a clear resource ('wisdom-mcp configuration'), so an agent can tell the basic purpose without opening the schema. It is not a tautology of the tool name, though it does not explicitly distinguish itself from siblings like wisdom_reload_config.

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

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

The description offers no guidance on when to call this tool instead of siblings such as wisdom_reload_config (reloads config) or wisdom_set_project (overlaps with the current_project parameter). There is no mention of the project-vs-global save decision, no exclusions, and no conditions that would rule this tool in or out.

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

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

No annotations are provided, so the description carries the behavioral burden. It clearly discloses the write/persist nature and adds a notable security trait: 'cryptographically signed knowledge fragment.' It could add more about reversibility, permissions, or failure behavior, but the core behavioral traits are well covered for a create 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?

Two concise sentences with no filler. The trigger conditions are front-loaded, immediately followed by the action and purpose. Every sentence contributes useful 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 no output schema, the description does not need to explain return values in depth. It explains when to call, what it does, and a key behavioral trait (cryptographic signing). For a simple create operation with one required parameter, this is nearly complete; it only lacks explicit notes on idempotency or error cases.

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

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

Schema description coverage is 100%, so the baseline is 3. The description does not detail parameter formats beyond the schema, but it reinforces that 'content' is the primary payload and that fragments are knowledge artifacts. This meets the baseline without exceeding it.

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

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

States a specific verb ('persist'), resource ('knowledge fragment'), and clear trigger conditions ('after solving a problem, discovering an insight, or making a decision'), making it easy to distinguish from siblings like wisdom_get_fragment or wisdom_create_tag.

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 explicit when-to-use context ('after solving a problem, discovering an insight, or making a decision') and notes the goal ('persist knowledge for future sessions'), which helps an agent decide when to invoke it. It does not explicitly name alternatives or exclusions, but the trigger conditions are strong enough for most selection scenarios.

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

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

With no annotations provided, the description carries the full burden of behavioral disclosure, yet it only states 'Create a new project' with no mention of side effects, default behaviors (set_as_current defaults to true, visibility defaults to public which syncs to hub), permissions required, or what happens after creation. For a mutating tool, this is a significant gap.

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

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

The single sentence 'Create a new project' contains no wasted words and is front-loaded, but it is under-specified to the point of bordering on restating the tool name. It earns its place but contributes minimal information beyond the name itself.

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 creation tool with 5 parameters, no annotations, and no output schema, the description is incomplete. It doesn't clarify return behavior, the default set_as_current=true behavior, or the public-visibility hub sync implication, leaving the agent to discover these from schema field descriptions alone.

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

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

Schema description coverage is 100%, so all five parameters (name, visibility, description, default_tags, set_as_current) are already well-documented in the schema itself, including the enum and default values. The description adds nothing about parameters, but the baseline of 3 applies because the schema does the heavy lifting.

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

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

The description uses a specific verb ('create') and resource ('project'), stating clearly what the tool does. It doesn't explicitly distinguish itself from siblings like wisdom_update_project, wisdom_set_project, or wisdom_clear_project, but the 'create' verb inherently separates it from update/set/clear/get/list operations.

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. An agent gets no context about prerequisites, when creating versus setting/updating a project is appropriate, or situations where a different sibling would be the right 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 are provided, so the description carries the full burden of behavioral disclosure. It only states that a relation is created, without revealing whether the relation is directional, whether source/target entities must already exist, whether duplicate relations are rejected, or whether creating relations affects downstream trust/evidence calculations. This is sparse for a mutation tool in a knowledge system.

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 13-word sentence that is front-loaded with the verb and resource. Every word earns its place, and nothing is repeated from the schema or annotations. Appropriately sized for the information it conveys.

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

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

For a mutation tool with no annotations and no output schema, the description is too thin. It omits success/failure return behavior, duplicate handling, directionality semantics, and any relation to the trust/evidence features hinted at by sibling tools such as wisdom_calculate_trust and wisdom_find_contradictions. The schema covers parameters well, but the behavioral context is incomplete.

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

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

Schema coverage is 100%, so the schema already documents all four parameters plus the full relation_type enum. The description adds only marginal context by identifying fragments and tags as valid entity types for source/target. With the schema doing the heavy lifting, the 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 states a specific verb ('create') and resource ('relation between two entities'), and clarifies that entities include fragments and tags. This distinguishes it from wisdom_get_relations, its read counterpart. However, 'etc.' leaves ambiguity about which entity types are valid (e.g., can agents or projects participate?), so it falls short of full 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 on when to use this tool versus alternatives. The description does not point to wisdom_get_relations for reading relations, nor does it distinguish this from wisdom_trust_agent or wisdom_link_answer, which likely create other kinds of links. An agent must infer usage entirely from the tool name and schema.

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

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

No annotations are provided, so the description carries the full burden of behavioral disclosure. It simply states that a tag is created, with no mention of duplicate handling, uniqueness enforcement, persistence, side effects, required permissions, or response behavior. For a mutation tool with zero annotation coverage, this is a notable gap.

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

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

The description is a single, direct sentence with no filler or redundant phrasing. It front-loads the core action and resource, making it easy to parse quickly. It is concise without sacrificing clarity.

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 create tool, the schema fully documents the parameters and the enum constrains category values. However, there is no output schema and no description of what the tool returns on success or how it handles duplicate names. Given the low complexity, this is minimally complete but leaves some practical invocation details unstated.

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

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

Schema description coverage is 100%, and the schema already documents name, category, and description, including the uniqueness note and the category enum. The description adds no additional parameter-level meaning. Per the baseline rule, this is adequate but not enhanced.

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 and resource: 'Create a new tag for categorizing fragments.' It identifies the tool as creating a tag entity, which is distinct from related operations like wisdom_tag_fragment. However, it does not explicitly name or differentiate itself from any sibling tool, so it stops short of full differentiation.

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

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

There is no guidance on when to use this tool versus alternatives such as wisdom_tag_fragment, wisdom_suggest_tags, or wisdom_list_tags. An agent must infer from the tool name that this creates a tag namespace rather than attaching an existing tag to a fragment. The description provides no exclusions or decision criteria.

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

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

There are no annotations, so the description carries the full burden of behavioral disclosure, and it only says 'Create a new transform specification.' It does not disclose that this is a persistent write operation, what identifiers or values it returns, whether duplicate names are rejected, or what validation is applied to transform_to/transform_from values. For a mutation tool with zero annotation coverage, this is a material gap.

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

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

The description is a single five-word sentence with no redundancy, so there is nothing to cut. However, its brevity borders on under-specification: for a 6-parameter creation tool it carries no usage, prerequisite, or behavioral context, so the economy is not earned by density of 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?

With no annotations and no output schema, the description is the only behavioral contract, and one sentence is insufficient for a creation tool with 6 parameters. The agent cannot learn what the call returns, whether side effects are reversible, or how this relates to the five other transform-related siblings. The schema covers parameters, but everything around invoking the tool correctly is missing.

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 every parameter is documented in the schema itself, including examples for transform_to ('text/markdown') and transform_from ('text/plain'). The description adds no parameter-level meaning beyond the schema, which sets the baseline at 3. additional_data ('Additional configuration (JSON)') is the vaguest parameter, but the description does nothing to clarify its expected structure.

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 action ('Create') and resource ('transform specification'), which is a complete verb+object construction. However, it never explains what a transform specification actually is (a reusable mapping from a source format like text/plain to a target format like text/markdown), so an agent must infer this from the schema. It also doesn't explicitly distinguish creation from the sibling transform-execution tools like wisdom_transform_to_fragment or wisdom_auto_transform, though the word 'specification' offers a hint.

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 create a transform versus using alternatives like wisdom_auto_transform, wisdom_transform_to_fragment, or wisdom_store_transformed_fragments, all of which are siblings. No prerequisites are mentioned — for instance, whether a project must be set (wisdom_set_project) or whether the tags parameter requires pre-existing tag UUIDs. The agent is left to guess when this tool is the right 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?

With no annotations provided, the description carries the burden of behavioral disclosure. The phrase 'searching for CONTRADICTS relations' usefully indicates this is a read-style lookup over existing relation data rather than a mutation. It does not explicitly confirm read-only behavior or describe what happens when nothing is found, but the language strongly implies a non-mutating search.

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 states the action, the target, and the mechanism in a compact way, 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?

For a one-parameter lookup tool, the description is mostly adequate: it names the operation, the resource, and the relation type. However, there is no output schema and the description does not state the return format, such as whether it returns matching relations, fragments, or some other structure. That leaves a moderate gap.

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

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

Schema description coverage is 100% and the only parameter, fragment_id, is already clearly documented as the UUID of the fragment to find contradictions for. The tool description adds no additional parameter semantics beyond what the schema provides, so the 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 uses a specific verb and resource: 'Find potential contradictions to a fragment' and further distinguishes the tool by stating it searches for 'CONTRADICTS relations'. This clearly separates it from general relation tools like wisdom_get_relations and other fragment operations.

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

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

The description implies the tool should be used when an agent needs contradictions for a specific fragment, and the single required fragment_id reinforces that. However, it does not explicitly state when not to use it or mention alternatives such as wisdom_get_relations for retrieving all relation types.

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

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

With no annotations provided, the description carries full disclosure burden but only names the two actions without their side effects. It omits that secret key material is persisted to disk, that gateway registration is on by default (register:true, while 'optionally' implies skipping is the safe default), and what the call returns. For a credential-generation tool this is a significant transparency gap.

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

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

A single 12-word sentence front-loads the core action and wastes nothing. The 'optionally register' clause earns its place by surfacing the tool's second behavior rather than burying it in the schema.

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

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

With no annotations and no output schema, the description must clarify defaults, side effects, and return values on its own. It clarifies none of these — an agent cannot tell whether the keypair is returned, printed, or only persisted, nor whether a repeat call overwrites an existing identity. This is thin for a security-sensitive setup tool.

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

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

Schema description coverage is 100%, with save_to, register, and description already fully documented including paths and defaults. The description adds only a rephrasing of the register behavior and no syntax, format, or default details beyond the schema. Baseline 3 is appropriate since the schema does the heavy lifting.

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

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

Names a specific verb and resource — 'Generate a new Ed25519 keypair' — with the algorithm specified, making the core action unmistakable. The secondary clause 'optionally register as a new agent' maps to the register parameter. Among 39 sibling tools, none performs keypair generation, so there is no ambiguity with alternatives.

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

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

The intended use case is implied: call this when you need an Ed25519 identity or a new agent. However, there is no explicit when-to-use or when-not-to-use guidance, no reference to alternatives, and no suggestion to check existing agents via wisdom_list_agents or wisdom_get_agent before creating a new identity. Usage context is inferable but never stated.

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

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

No annotations are provided, so the description carries the behavioral disclosure burden. It only says 'get,' which implies a read operation, but it does not mention authentication needs, side effects, or what happens when no UUID is provided. It is not misleading, but it adds little beyond the operation 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 one short, front-loaded sentence with no filler. It is efficient and easy to parse, though the brevity sacrifices usage and behavioral context that would otherwise support tool selection.

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

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

For a single-parameter read tool with no output schema, the description is minimally viable, but it omits what 'agent information' contains and does not mention the current-agent fallback behavior. The fallback is only discoverable in the schema, and the return shape is entirely unspecified.

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

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

Schema description coverage is 100%, and the uuid parameter description already documents that it 'uses current agent if not specified.' The tool description adds no parameter-level meaning, so the baseline score of 3 is appropriate.

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

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

The description states a specific verb and resource: 'Get agent information by UUID.' It is clear that this is a single-agent retrieval operation, and it is implicitly distinguished from wisdom_list_agents by the UUID-based lookup. However, it does not explicitly name sibling alternatives or describe what 'agent information' includes.

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 like wisdom_list_agents or wisdom_whoami. The only usage hint, that omitting uuid uses the current agent, is in the parameter schema rather than the tool 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?

With no annotations provided, the description carries the full behavioral burden. 'Find' and 'Returns weighted scores' suggest a read-only query and disclose the output type, but the description does not explain how evidence is gathered, whether the operation has side effects, or what the weighted scores actually represent in more detail.

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

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

The description is two short sentences with no filler. It front-loads the core action, names the resource, and briefly states the return characteristic ('weighted scores'), 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 tool is simple with only one parameter, but the absence of an output schema and annotations means the description should clarify the return shape. 'Returns weighted scores' is somewhat vague and does not explain the structure, edge cases, or limitations of the evidence search, leaving room for agent uncertainty.

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 100% description coverage for the only parameter, fragment_id, described as 'UUID of the thesis fragment to analyze.' The description's phrase 'for a thesis fragment' adds no additional semantic value beyond what the schema already provides, so the baseline score of 3 is appropriate.

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

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

The description uses a specific verb and resource: 'Find all supporting and contradicting evidence for a thesis fragment.' This clearly distinguishes the tool from siblings like wisdom_get_fragment, wisdom_search_fragments, and wisdom_find_contradictions by focusing specifically on evidence balance.

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 its use case well enough, but it does not explicitly state when to use this tool versus alternatives, nor does it mention any exclusions or prerequisite conditions. It relies on the agent inferring that this is the right tool for evidence-balance queries.

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

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

No annotations are provided, so the description carries the full burden of behavioral disclosure. It only says 'Retrieve a fragment by UUID,' which adds little beyond the tool name. It does not state what is returned, whether errors occur for missing UUIDs, or whether any side effects exist.

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 filler and the key information is front-loaded. It is appropriately concise for a simple one-parameter retrieval tool, though it is slightly under-specified in terms of behavioral context.

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 trivial single-parameter get operation, the description is minimally adequate for selecting and invoking the tool. However, with no output schema and no annotations, it leaves the return value and the distinction from list/search tools unexplained, which a fuller description could have covered.

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%: the only parameter, uuid, is documented as 'Fragment UUID.' The description repeats this concept without adding format, example, or constraint details, so it provides no meaningful value beyond the schema.

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

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

The description states a specific verb ('Retrieve') and resource ('fragment') with the access key ('by UUID'). This makes the core function clear and distinguishes it from siblings like wisdom_list_fragments and wisdom_search_fragments, though it does not explicitly name those alternatives.

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

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

The phrase 'by UUID' implies the tool should be used when a specific fragment identifier is known. However, there is no explicit guidance about when to prefer this over wisdom_list_fragments or wisdom_search_fragments, and no exclusions or prerequisites are mentioned.

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. 'Get' implies a read operation, but the description does not explain what a trust vote is, whether the result is a list or an aggregate, or what data is returned.

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

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

The description is a single, tightly scoped sentence with no filler. The key operation and target resource are front-loaded, making it 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?

The tool is simple and its parameter is documented, but with no output schema and no annotations, the description omits important context about the response shape or behavior. It would be more useful if it clarified what 'trust votes' means or what the caller receives.

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

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

The input schema already documents the only parameter as a Fragment UUID with full coverage. The description adds no additional parameter-level meaning, so the schema does the necessary work.

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

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

The description clearly identifies the operation ('Get') and the resource ('trust votes for a fragment'). It does not explicitly distinguish itself from siblings like wisdom_vote_on_fragment or wisdom_calculate_trust, but the retrieval intent is clear enough from the name and description.

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

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

The intended use is implied: retrieve trust votes for a fragment. However, there is no explicit guidance on when to use this tool versus alternatives such as wisdom_vote_on_fragment or wisdom_calculate_trust.

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

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

With no annotations, the description carries the burden of indicating safety and side effects. 'Get' clearly signals a read-only operation, but the description does not disclose what happens when no current project exists, an invalid UUID is provided, or whether the returned data is partial or full.

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

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

One compact, front-loaded sentence with no filler. Every word contributes to defining what the tool does.

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 getter with one optional parameter, the description plus schema is adequate for basic invocation. However, there is no output schema and no mention of return shape or error cases, and the description does not point to list_projects as the alternative for enumerating projects.

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%; the schema already explains that uuid is optional and defaults to the current project. The tool description adds no new parameter-level detail beyond restating this 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?

States a specific verb ('Get') and resource ('project'), and defines two distinct access modes: the current project or a project identified by UUID. It does not explicitly contrast with sibling tools like list_projects, so it stops short of full differentiation.

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

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

The phrase 'current project or a specific project by UUID' implies the main use case, but there is no explicit guidance about when to prefer this over list_projects, how a UUID should be obtained, or prerequisites such as having a current project configured.

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. 'Get' implies a read-only operation, but the description does not clarify return behavior, whether both directions are returned by default, or whether the entity may appear as source, target, or both.

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

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

The description is a single waste-free sentence that front-loads the core action. It is appropriately short, though it is concise at the cost of omitting useful behavioral and contextual details.

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

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

For a simple two-parameter getter whose schema documents all parameters, the description is minimally usable. However, with no output schema and no mention of direction semantics or result shape, it is not fully self-sufficient for an agent choosing among relation-related siblings.

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

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

Schema description coverage is 100%, and both parameters are already documented clearly in the schema. The description adds no additional meaning beyond the schema, so the baseline of 3 applies.

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

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

The description uses a specific verb ('Get') and resource ('relations for an entity'), clearly identifying a read/query action. It is not a tautology and is understandable on its own, though it does not explicitly distinguish itself from relation-adjacent siblings like wisdom_check_derivation_chain.

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 instead of alternatives such as wisdom_create_relation, wisdom_get_fragment, or wisdom_find_contradictions. The agent is left to infer the appropriate context from the tool name alone.

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

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

With no annotations, the description itself must convey behavioral context. 'Get' plus the lookup behavior makes it clear this is a read-only retrieval and identifies the lookup mechanism, but the description does not disclose what happens when both parameters are supplied, when neither is supplied, or when the tag is not found.

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

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

A single, front-loaded sentence that wastes no words. Every phrase ('Get', 'tag', 'by UUID or name') contributes to understanding the operation.

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

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

For a simple retrieval tool with only two parameters, this is nearly sufficient: an agent knows what to retrieve and how to identify it. Yet the absence of any instruction about parameter optionality/one-of and return shape leaves minor gaps that matter in an agent-invocation 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 input schema already documents both parameters with 100% coverage, so the baseline is 3. The description reinforces that UUID and name are alternative identifiers, but adds no new semantics such as precedence or a one-of requirement.

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 pinpoints the operation with a specific verb and resource: 'Get a tag', and narrows lookup scope to 'UUID or name' – enough to distinguish it from siblings such as wisdom_list_tags (bulk listing) and wisdom_create_tag (creation). No ambiguity remains about what this tool does.

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 implies the right use case: use this tool when you already know a tag's UUID or name and want that tag. However, it does not explicitly mention alternatives like wisdom_list_tags for enumeration, nor say that exactly one of name/uuid should be provided, so the guidance is only implicit.

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 and no output schema, so the description carries the full behavioral burden. 'Get' suggests a read operation, but the description does not disclose error behavior for missing/invalid UUIDs, whether authentication is required, or what the response contains beyond the specification itself.

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 7-word sentence with no filler and the key information front-loaded. It is appropriately sized for a simple one-parameter getter, though it is also minimal enough to feel slightly under-specified.

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

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

For a low-complexity tool with one required parameter, the description is nearly complete: the agent knows the action and the key. However, with no output schema and no mention of failure semantics or relationship to sibling transform tools, there is a minor but real completeness gap.

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

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

The single parameter 'uuid' is fully covered in the schema with description 'Transform UUID', so the schema does the heavy lifting. The description adds only 'by UUID', which adds no meaningful semantics 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 states a specific verb ('Get'), a clear resource ('transform specification'), and the lookup mechanism ('by UUID'). This distinguishes it from sibling listing tools such as wisdom_list_transforms, though it doesn't explicitly name alternatives.

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

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

The description implies use when the agent has a UUID and needs a single transform specification, but it gives no explicit when-to-use guidance and no comparison against alternatives like wisdom_list_transforms or wisdom_get_fragment. The agent must infer the appropriate context.

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

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

With no annotations available, the description carries full responsibility for disclosing behavior, but it only says 'Link' without mentioning side effects, persistence, prerequisites, duplicate handling, or return behavior. This leaves important mutation semantics undisclosed.

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

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

A single sentence with no filler; the core action and object pair are front-loaded. Every word is relevant, and the structure is easy to scan.

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

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

The tool has no output schema and no annotations, yet the description does not mention return values, error conditions, or what kind of relation is created. For an agent deciding whether this is the right link operation, important context is missing.

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 parameters are already documented as 'Question fragment UUID' and 'Answer fragment UUID'. The description adds no significant semantic detail beyond restating these roles.

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 operation as 'Link an answer fragment to a question fragment', identifying both the verb and the involved resources. It is specific enough to convey the tool's core purpose, though it does not explicitly contrast it with siblings like wisdom_create_relation.

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 instead of wisdom_create_relation, wisdom_get_relations, or other fragment operations. The intended context must be inferred entirely from the tool name and terse 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 full burden of behavioral disclosure. The bare phrase 'List known agents' reveals nothing about pagination behavior, result ordering, authentication requirements, or whether the result reflects a local registry vs a remote source. The only behavioral signal is the read-only nature implied by the verb '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?

Three words with zero filler, and the core verb+resource is front-loaded. However, this borders on under-specification rather than true conciseness — the sentence is too thin to convey meaning beyond the tool name itself.

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

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

For a tool with no annotations and no output schema, the description should clarify what 'known agents' means and note pagination behavior, but it does neither. The minimum viable description for a list tool would at least mention what collection is being listed and how results are returned.

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

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

Schema description coverage is 100% — both 'limit' and 'cursor' are fully documented in the schema, including the default for limit. The description adds no parameter information, but per baseline rules this is acceptable when the schema carries the full load.

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

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

The description states a specific verb ('List') and resource ('known agents'), and the resource name clearly differentiates it from sibling listing tools like wisdom_list_fragments, wisdom_list_tags, and wisdom_list_projects. However, the qualifier 'known' is ambiguous — it doesn't clarify whether these are locally registered agents, trusted agents, or some other subset.

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 usage guidance is provided at all. The description doesn't explain when to use this tool vs the closely related sibling wisdom_get_agent (retrieve a single agent), nor does it differentiate from the other list tools. An agent must infer entirely from the tool name which tool fits the task.

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 zero annotations, the description carries the full behavioral burden. It implies a read-only listing but never states it, and the only behavioral disclosure is 'recent' (ordering). It says nothing about pagination flow, how the project filter scopes results, or what the response contains, which is thin given the absence of an output schema.

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

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

Three words is efficient and front-loaded with the verb, but it borders on under-specification. The brevity sacrifices the opportunity to clarify the list-vs-search distinction or the meaning of 'recent,' making it concise without being informative.

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

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

Given no output schema and no annotations, the description is the sole source of context, yet it leaves major gaps: the relationship with wisdom_search_fragments, the pagination cursor flow, and project-scoping defaults are all undocumented at the description level. With multiple sibling list_* tools, an agent needs more to reliably select and invoke this tool.

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

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

Schema description coverage is 100%, so limit (default 20), cursor (pagination), and project (UUID filter, defaults to current project) are already fully documented in the schema. The description adds no parameter-level meaning, but the baseline of 3 applies because the schema carries the full load.

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

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

The description states a specific verb ('List') and resource ('fragments'), with 'recent' adding a recency-ordering qualifier that goes beyond a bare tautology. However, it fails to differentiate from the closest sibling, wisdom_search_fragments — an agent cannot tell from the description when to use list vs search.

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 usage context is provided. The description never addresses the key routing decision between this tool and wisdom_search_fragments, nor does it mention when project filtering or cursor pagination would be appropriate. There is no 'use X instead when...' guidance.

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

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

With no annotations provided, the description carries the full burden. The word 'List' clearly signals a read-only operation and 'current agent's' adds a meaningful scoping behavior. However, it does not disclose operational details such as authentication requirements, error behavior, whether an empty list is possible, or any effects on state beyond the implicit read-only nature.

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, direct sentence with no wasted words. It states the action, resource, and scope efficiently, which is ideal for quick agent parsing.

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 simple, requires no parameters, and the schema fully describes the optional parameters. However, there is no output schema and the description does not mention what a returned project entry contains or how pagination results appear, leaving some uncertainty about the response shape.

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

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

Schema description coverage is 100%, so the schema already documents both parameters (limit and cursor) including the default for limit. The description adds no additional parameter context, which is acceptable because the schema fully covers parameter meaning; 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 names a specific verb ('List'), a specific resource ('projects'), and a clear scope ('current agent's'), which distinguishes it from sibling tools like wisdom_list_fragments, wisdom_list_tags, and wisdom_list_agents. An agent can immediately understand what this tool returns and who it is scoped to.

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

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

The usage is implied: call this when you need the projects belonging to the current agent. However, there is no explicit guidance about when to prefer this over related tools like wisdom_get_project, wisdom_set_project, or wisdom_update_project, and no mention of alternatives or exclusions.

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

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

With no annotations, the description carries the full burden of behavioral disclosure. 'List' implies a read-only retrieval operation, which is useful but not explicit. The description does not mention pagination behavior, ordering, or whether the result is a flat array or paged object, though the schema hints at pagination via cursor.

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. 'List tags, optionally filtered by category' conveys the core operation and a key variation in minimal 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?

The tool is simple and all parameters are optional and well documented in the schema. However, there is no output schema and no annotations, so a slightly richer description mentioning that this returns existing tags or that pagination is controlled via cursor would make it more complete for an agent.

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

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

Schema description coverage is 100%, so the baseline is 3. The description only mentions the category filter and adds no meaning beyond what the schema already documents for limit, cursor, or category. It does not clarify how limit and cursor interact.

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 and resource: 'List tags'. It also adds the optional category filter, which helps the agent understand the tool's scope. It does not explicitly differentiate from siblings like wisdom_get_tag or wisdom_suggest_tags, but 'list' is distinct enough from create/get/suggest.

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 explicit guidance on when to use this tool versus alternatives such as wisdom_get_tag or wisdom_suggest_tags. It does not mention any exclusions or conditions. The intended usage is only implied by the verb 'List'.

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

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

No annotations are provided, so the description carries the full burden of behavioral disclosure. It merely restates the tool name and adds no traits such as read-only behavior, pagination, default limits, or what 'available' means. The word 'list' weakly implies a read operation, but the description adds no value 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 only three words and contains no filler, but it is essentially a restatement of the tool name. The sentence could have been used to clarify scope ('transform definitions') or mention filtering, but instead it adds no distinct informational 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?

For a simple list tool with two optional parameters fully described in the schema, 'List available transforms' is minimally viable—an agent knows what action it performs and can rely on the schema for parameter semantics. However, with no output schema, no annotations, and no explanation of what a transform is, the description is not fully complete.

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

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

The schema fully documents both parameters (limit and domain) with descriptions, so the baseline is 3. The description itself does not add any extra meaning about how these parameters affect the results, but the 100% schema coverage means that deficiency is not critical.

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

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

The description uses a clear verb ('List') and resource ('available transforms'), and the tool name distinguishes it from siblings like wisdom_get_transform and wisdom_create_transform. However, 'available transforms' is slightly ambiguous—it does not explicitly say whether these are transform definitions, instances, or templates—so it is clear but not fully precise.

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

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

The description offers no guidance on when to use this tool versus alternatives such as wisdom_get_transform or wisdom_create_transform. There is no mention of appropriate contexts, exclusions, or relationships to sibling tools, leaving the agent to infer usage on its own.

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

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

With no annotations provided, the description carries the transparency burden. It transparently states that the tool searches the network, filters by trust and confidence, and respects a token budget. However, it does not explicitly say whether the operation is read-only, what the exact return structure is, or whether it has side effects, leaving some ambiguity.

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

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

The description is two sentences with no filler. The first sentence front-loads the critical usage directive, and the second sentence concisely describes the core behavior and filters. Every phrase earns its place.

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

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

For a 4-parameter retrieval tool with no output schema or annotations, the description adequately conveys the purpose, main behavior, and return type ('fragments'). It does not detail the return format or mention the project filter, but the schema covers the project parameter and the overall behavior is simple enough to call correctly.

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

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

Schema description coverage is 100%, so the schema already documents all four parameters. The description mentions 'trust', 'confidence', and 'token budget' generically but does not add parameter-specific meaning 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 identifies the action ('load relevant prior knowledge') and the resource ('wisdom network'/'fragments'), and explains the search/filter behavior. However, it does not explicitly distinguish itself from the sibling tool wisdom_search_fragments, which likely performs a similar search.

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 an explicit when-to-use directive: 'ALWAYS call this at the start of any task'. It does not mention any exclusions or alternative tools, so it stops short of 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?

With no annotations, the description carries the full transparency burden. It discloses the conditional side effect of registering the agent and lists the other steps, but 'verify project' is ambiguous and the description does not cover output, errors, or additional 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 two short sentences with no filler. The action list is front-loaded, and the usage directive is compact and clear.

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

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

For an orchestrating tool with no output schema and no annotations, the despription covers the core flow but omits return value, failure modes, and behavior when the agent or project is not present. It is adequate for basic invocation but not fully complete.

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

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

The schema already has 100% parameter coverage, so the baseline is 3. The description only loosely maps task_description and agent_description to the setup steps without adding meaningful new parameter-level detail.

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 a specific composite operation: checks the agent, registers it if needed, verifies the project, and loads context for the current task. This is clear and distinct from the other wisdom_* tools, though no specific sibling is named as the alternative.

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

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

The description explicitly says to call this instead of making multiple separate setup calls, giving a clear usage rule. It does not mention edge cases where a more targeted tool like wisdom_load_context_for_task would be better.

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

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

No annotations are provided, so the description carries the full burden of behavioral disclosure. It only says that configuration is reloaded from disk; it does not disclose side effects, such as whether current in-memory settings are overwritten, whether a restart is needed, or what happens if the disk configuration is invalid.

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 redundant phrasing. Every word contributes meaning, making it highly concise.

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 low complexity (zero parameters, no output schema), a short description is acceptable, but it leaves out important context: when to call it, what reloading actually changes, and what the agent should expect in return. It is minimally viable but not fully complete.

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

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

The input schema has zero parameters and the schema description coverage is 100%, so there is nothing for the description to clarify about parameters. The description correctly implies an argument-free operation.

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 ('reload') and a resource ('configuration from disk'), so an agent can at least recognize this as a configuration-reload utility. It is not a pure tautology because it adds the source location, though it does not explicitly differentiate from related tools like wisdom_configure.

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 this tool should be used, when it should not be used, or how it relates to sibling tools such as wisdom_configure or wisdom_quickstart. The agent must infer the intended context entirely from the name and the sibling list.

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, but it only restates the operation. It says nothing about read-only behavior, result ordering or pagination, what happens with an empty query (all parameters are optional), or response characteristics, with no output schema to fill the gap.

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

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

The six-word sentence is front-loaded with the verb and resource and contains zero filler; every word earns its place. It is appropriately compact, though the brevity shifts informational burden onto other dimensions.

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

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

For a 6-optional-parameter search tool with no annotations and no output schema, a single sentence is insufficient. The agent cannot tell how this differs from wisdom_list_fragments, whether filters combine additively, how defaulting works, or what the search returns, leaving meaningful gaps for a tool of this complexity.

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%, with each of the 6 parameters already documented (tags, limit, query, state, author, project), so the schema does the heavy lifting. The phrase 'text query and filters' maps to those parameters but adds no detail beyond what the schema already provides, so the baseline 3 applies.

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

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

The description states a specific verb ('Search'), a resource ('fragments'), and the mechanism (text query and filters), so an agent can immediately grasp the core purpose. It implicitly distinguishes from siblings like wisdom_get_fragment (single fetch) and wisdom_list_fragments (plain listing), though it never names them or the distinction explicitly.

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

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

No guidance is given about when to choose this tool over alternatives. With siblings like wisdom_list_fragments, wisdom_get_fragment, and wisdom_find_contradictions, the agent gets no conditions, exclusions, or alternative-tool routing, leaving selection 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?

No annotations are provided, so the description carries the full burden of behavioral disclosure. It only states that the tool sets the current project context; it does not mention that this mutates the active project state, that persistence to a config file can be controlled, or what side effects future commands may see.

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 wasted words and the core action is front-loaded. It is concise, though almost too terse to fully convey the tool's purpose and effects.

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 state-changing tool with no annotations and no output schema, the description is too thin. It does not explain that this changes the active project for subsequent operations, that persistence is configurable, or how it relates to the sibling get/clear project tools. A two-sentence description could easily make this complete.

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

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

Schema description coverage is 100%, so the schema already documents the 'project' UUID and 'persist' flag. The description adds little beyond the schema, but because the schema is fully covered, the 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 'Set the current project context' uses a clear verb ('set') and a specific resource ('current project context'), and it is distinct from the sibling wisdom_get_project and wisdom_clear_project. It is not a tautology, though it does not explicitly differentiate itself from those 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?

No guidance is given about when to use this tool versus alternatives like wisdom_clear_project or wisdom_get_project. The description implies a context-switching use case but provides no exclusions, prerequisites, or situational advice.

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

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

No annotations are provided, so the description must disclose effects itself. It only says it stores fragments and optionally tracks compression metrics; it does not state whether storing overwrites existing fragments, requires a transform UUID, or has any side effects beyond persistence.

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

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

The description is one sentence with no filler, and the primary purpose is stated first. Every phrase earns its place.

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

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

With no annotations and no output schema, the description leaves important calling context unstated: there is no mention of return values, error behavior, whether the operation is additive/overwriting, or how source_transform connects to existing transform records. The agent knows what to pass but not what to expect.

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

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

Schema description coverage is 100%, so the baseline is 3; the description does not need to repeat parameter definitions. It adds value by explaining that original_content is used for compression metrics, but does not add new meaning for fragments, project, or source_transform.

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 action ('Store fragments') and a specific resource ('fragments that were transformed by the host'), which distinguishes it from generic fragment creation. It does not explicitly name a sibling tool, but the 'transformed by the host' qualifier gives enough scope.

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

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

There is no explicit guidance on when to use this tool versus alternatives such as wisdom_create_fragment or wisdom_transform_to_fragment. The phrase 'that were transformed by the host' implies the context, but no when-to-use or when-not-to-use conditions are stated.

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

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

With no annotations provided, the description carries the full burden of behavioral disclosure. It adds value by revealing that the operation delegates to the host for LLM-based analysis, implying external dependency and potential latency. However, it does not disclose the return format (no output schema exists), failure modes, whether results are persisted, or 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?

A single 13-word sentence with zero waste. The core purpose ('Request tag suggestions for content') is front-loaded, and the mechanism detail is appropriately tucked into a parenthetical. Every word earns its place.

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

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

Adequate for a simple 2-parameter tool, but gaps remain: no usage guidance, no return-value description despite lacking an output schema, and no mention of latency or failure implications of the host delegation. The tool is simple enough that these omissions are moderate rather than severe.

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

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

Schema description coverage is 100%, so both parameters (content and max_suggestions) are already documented with meaningful descriptions in the schema. The description adds no parameter-level detail beyond what the schema provides, so the baseline 3 applies.

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

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

States a specific verb ('Request') and resource ('tag suggestions for content'), clearly distinguishing it from sibling tools like wisdom_create_tag (manual creation) or wisdom_list_tags (listing). The parenthetical about LLM-based analysis adds helpful mechanism context. Slightly generic verb choice prevents a 5, and it doesn't explicitly name an alternative to differentiate from.

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

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

No guidance on when to use this tool versus alternatives such as wisdom_create_tag or wisdom_tag_fragment. The parenthetical explains the mechanism (host delegation) but not the usage context, so an agent cannot determine whether this tool is appropriate for a manual tagging workflow or when LLM-based suggestions are preferred.

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. 'Apply a tag via relation' implies a state-changing operation, but it does not disclose whether the operation is idempotent, whether duplicate relations are prevented, whether the tag can be created on the fly, or what side effects 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 sentence with no wasted words and the core action is front-loaded. It could provide more behavioral context, but as written it is concise 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?

For a simple two-parameter operation with full schema coverage, the description is minimally viable: an agent can identify the inputs. However, with no annotations, no output schema, and no information about relation semantics or tag existence requirements, there are enough gaps that the description is not fully complete.

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

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

Schema description coverage is 100%, with both parameters already documented as 'Tag UUID or name' and 'Fragment UUID'. The description adds no new meaning beyond the schema, so the baseline score of 3 is appropriate.

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

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

The description states a specific action (apply a tag) and a target resource (a fragment), and clarifies the mechanism ('via relation'). It is clear enough to distinguish from generic relation-creation tools like wisdom_create_relation, though it could be more explicit about whether the tag must already exist.

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 wisdom_create_relation, wisdom_create_tag, or wisdom_link_answer. There are no stated prerequisites, exclusions, or context cues beyond the sibling tool names, leaving the agent to infer the intended use case.

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 parenthetical 'delegates to host for LLM-based transformation' is a useful behavioral disclosure, indicating that the operation depends on host-side LLM processing. However, with no annotations present, the description still does not clarify whether the transformation mutates or stores anything, what happens to the original fragment, or what the return value is.

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 communicates purpose, direction, and implementation mechanism without redundancy or filler. It is well front-loaded and every word earns its place.

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

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

The tool has no output schema and no annotations, so the description must explain expected behavior and return semantics, but it does not. It leaves unclear whether the tool returns transformed text, stores a result, or only triggers a transformation, especially given the existence of sibling tools like `wisdom_store_transformed_fragments`.

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

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

Schema description coverage is 100%, so the schema already documents all three parameters. The description adds meaningful direction by specifying that fragments are English and are transformed 'back' to a target language, which clarifies the roles of `fragment_uuid` and `target_language` beyond the schema text.

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: it transforms English fragments back into a target language, with a parenthetical noting host delegation. This makes the core purpose clear, though it does not explicitly name or contrast the similar sibling `wisdom_transform_to_fragment`.

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 instead of `wisdom_transform_to_fragment`, `wisdom_auto_transform`, or related transform tools. There are no prerequisites, exclusions, or conditions stated, so the agent must infer usage from the tool name and 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 full burden of behavioral disclosure. It does reveal that the tool delegates to the host for LLM-based transformation, but it does not say whether the operation has side effects, whether it persists the resulting fragment, or what the agent can expect as a return value.

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 efficiently worded sentence that front-loads the main action and includes a useful implementation note. No filler or redundant repetition of the tool name or schema fields is present.

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 too thin for a tool with no annotations, no output schema, and several optional parameters. It fails to explain whether the transformation result is returned directly, stored, or requires additional steps such as wisdom_store_transformed_fragments, leaving ambiguity for an agent deciding how to use the output.

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

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

Schema description coverage is 100%, so the baseline is 3 even without additional parameter detail in the description. The description adds the 'English' target and LLM delegation context, but it does not clarify the meaning of transform_uuid or domain 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 states a clear verb and resource: it transforms input content into English knowledge fragments. This identifies the tool's core function and separates it from simple CRUD siblings, though it does not explicitly differentiate it from closely related tools like wisdom_transform_from_fragment or wisdom_auto_transform.

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 choose this tool over alternatives, nor any exclusions or prerequisites. The description implies a transformation use case but leaves the agent to infer which sibling should be selected.

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

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

No annotations are provided, so the description carries the full burden of behavioral disclosure. It does not mention whether the trust expression is persisted, whether it overwrites prior trust, what the side effects are, or any authorization requirements. The verb 'express' hints at a write operation, but important behavioral traits are omitted.

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 filler or repetition. The core action is front-loaded and easy to parse. While it is under-specified, that issue is better captured under contextual completeness; from a conciseness standpoint it is efficient.

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 three parameters, no annotations, and no output schema, the description is too minimal to fully guide invocation. It does not explain the effect of the operation, the meaning of the confidence parameter in context, or what the agent should expect in return. An agent would need to infer too much.

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 parameters like target_agent and trust_level are already well documented. The description does not add meaning beyond what the schema supplies. With full schema coverage, 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 verb ('Express') and resource ('another agent'), making the core action clear. It is not a tautology, and it contrasts with sibling tools like wisdom_calculate_trust, which imply computation rather than expression. However, it stops short of saying what 'express trust' concretely does (e.g., records a trust assessment), so it lacks the full specificity of a 5.

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

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

There is no guidance about when to use this tool versus alternatives such as wisdom_calculate_trust or wisdom_vote_on_fragment. No context, prerequisites, or exclusions are provided. The description simply states the action, leaving the agent to infer the appropriate scenario.

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

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

With no annotations, the description must carry the transparency burden. It clearly indicates a mutation ('assigns') and the mechanism ('TYPE tag relation'), which is useful. However, it does not disclose whether the type replaces an existing one, whether multiple types are allowed, or what the operation returns, leaving some behavioral ambiguity.

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. It front-loads the key usage instruction, then states the action and mechanism, making it easy to scan and act on.

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

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

This is a simple tool with two straightforward parameters, no output schema, and no nested objects. The description covers the action, the timing, and the semantics sufficiently for an agent to invoke it correctly. Minor gaps around idempotence and return value exist, but they are not critical for this low-complexity tool.

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

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

Schema description coverage is 100%, so both parameters are already documented in the schema. The description adds context by clarifying that fragment_type is a semantic type and providing examples, but it does not meaningfully enhance the schema's parameter explanations, so the baseline 3 applies.

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

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

The description states a specific verb ('classify'), a concrete resource ('fragment'), and the result ('assigns a semantic type via TYPE tag relation'). It also distinguishes itself from the sibling wisdom_tag_fragment by focusing on semantic types like QUESTION and ANSWER, so an agent can understand its role without opening the schema.

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

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

The description explicitly says when to call it: 'immediately after creating a fragment.' This gives clear contextual guidance. It does not mention when not to use it or name alternatives like wisdom_tag_fragment, so it stops short of a full 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?

No annotations are provided, so the description carries the full burden of behavioral disclosure. It only says 'Update project settings' and does not describe side effects, whether the update is partial or full, whether existing values are overwritten, or how the optional uuid behavior works. The schema supplies some detail, but the description itself is behaviorally thin.

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 short and free of clutter, but it is also under-specified. It is a single generic phrase with no additional context, so while it is concise, it does not use its brevity to deliver meaningful supporting 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?

With five optional parameters, no output schema, and no annotations, an agent has limited information about what happens when calling this tool, what a successful update returns, or what constraints exist. The schema explains parameter meanings, but the description fails to clarify operational context such as whether at least one parameter is expected or how the tool behaves with no parameters supplied.

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

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

Schema description coverage is 100%, so the baseline is 3 even though the description adds no parameter-level detail. The schema already documents each field, including the uuid fallback and visibility sync behavior, so the description does not need to repeat that information.

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

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

The description uses a clear verb ('Update') and resource ('project settings'), which conveys the core operation. It does not explicitly distinguish itself from sibling tools like wisdom_set_project or wisdom_create_project, but the word 'settings' narrows the scope enough to be understandable.

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

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

There is no guidance about when to use this tool versus alternatives such as wisdom_set_project, wisdom_create_project, or wisdom_clear_project. No context, exclusions, or prerequisites are mentioned, leaving the agent to 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?

No annotations are provided, so the description carries the full burden of behavioral disclosure. It clearly communicates the action, but it does not disclose important behavior: whether casting a vote is idempotent, whether a user can have only one vote per fragment, what 'retract' means for an existing vote, or whether any permissions are required. For a state-changing trust operation, this is a significant gap.

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

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

A single, well-structured sentence that leads with the action, names the resource, and lists the vote options. There is no filler or redundant information, and the description is immediately scannable.

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

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

The tool has no annotations and no output schema, so the description is the only source of behavioral context. While the input schema fully covers parameter syntax, the description omits the effect of voting, whether votes are replaceable, and what the caller should expect in response. Given the trust-related semantics and the existence of related vote/trust tools, this is incomplete for confident 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 100%, so the parameters are already well documented. The description adds no further meaning beyond listing the vote_type enum values, which the schema already provides. This meets the baseline for schema-driven parameter clarity but adds no extra semantic value.

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 ('Cast'), a clear resource ('a trust vote on a fragment'), and enumerates the allowed vote types. It is immediately distinguishable from sibling tools like wisdom_get_fragment_votes (reading votes) and wisdom_trust_agent (trusting an agent), so an agent can tell what this tool does without inspecting the schema.

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

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

The description implies the context: you use this when you want to express trust in a fragment by verifying, contesting, or retracting. However, it does not explicitly mention when not to use it or point to alternatives such as wisdom_get_fragment_votes for inspecting existing votes. The guidance is adequate but relies on 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 carries the behavioral burden. It successfully communicates that this is an introspection/connectivity check rather than a mutation, and it discloses the surfaced information. It could go further by stating it has no side effects or describing failure behavior, but the read-only nature is strongly implied by 'verify' and 'shows.'

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

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

Two short sentences with no filler. The first sentence gives the trigger and purpose, and the second enumerates the output contents. Every word earns its place.

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

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

For a zero-parameter, no-output-schema tool, the description is complete: it explains when to call it, what it verifies, and what information it returns. An agent can invoke this tool with full confidence about its expected behavior.

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

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

The input schema has zero parameters and 100% schema description coverage, so there is nothing for the description to add about argument semantics. With zero parameters, the baseline is 4; the description appropriately focuses on behavior instead of 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 action — 'verify agent identity and gateway connectivity' — and lists exactly what will be shown: agent identity, project context, and gateway configuration. This clearly distinguishes it from sibling tools like wisdom_get_agent or wisdom_get_project, which target individual 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 gives an explicit, actionable trigger: 'Call this at the start of each session.' It does not explicitly mention when not to use it or name alternatives, but the timing instruction is clear enough for an agent to decide when this tool is appropriate.

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