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

No annotations are present, so the description carries the full burden of behavioral disclosure. It only states that pages are created, but does not explain duplicate handling, partial failure behavior, atomicity, overwriting behavior, or permissions. For a bulk mutation 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?

The description is extremely concise and front-loaded, with no filler words. However, it is under-specified for a bulk creation operation and provides no structural information or useful context beyond a near-restatement of the tool name.

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 input schema is rich and covers parameters, but there are no annotations, no output schema, and the description offers no usage guidance, no behavioral caveats, and no distinction from sibling tools beyond the word 'bulk'. An agent can infer the basic operation but not the risks, failure modes, or when this tool is the correct choice.

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

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

Schema description coverage is 100%, and the input schema already fully documents the 'pages' array and its per-item properties such as title, content, path, tags, isPrivate, description, and isPublished. The description adds no parameter-level meaning beyond the name of the action, 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 states a specific action ('Create multiple pages') and a clear resource ('pages'), and the word 'bulk' distinguishes it from single-page creation siblings like wikijs_create_page and wikijs_create_nested_page. Despite being terse, the purpose is unambiguous.

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

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

The wording implies the tool should be used when creating multiple pages at once, but it never explicitly says when to prefer this over wikijs_create_page or when not to use it. No alternatives, conditions, or exclusions are mentioned, leaving usage mostly inferred from the name and 'bulk' phrase.

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. 'Test' and 'get' imply a read-only, non-mutating operation, which is helpful, but the description does not mention failure behavior, network dependency, or what specifically happens if the connection is unavailable. For a zero-parameter status tool, this is minimally adequate but not rich.

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

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

The description is a single concise sentence that states both the primary action and the expected result. Every word contributes value, and there is no redundant filler or repetition of the tool name.

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

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

Given the tool's low complexity, zero parameters, and lack of annotations or output schema, the description is mostly sufficient for an agent to understand the purpose and invoke it correctly. It could be more complete by specifying what 'basic site information' includes, and by clarifying how this differs from wikijs_get_site_info, but these are minor for a simple connection test.

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

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

The tool has zero parameters and the schema is trivially fully covered, so there are no parameter semantics for the description to clarify. Baseline for zero-parameter tools is 4, and the description does not introduce any conflicting or unnecessary parameter-related 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 clearly states a specific verb ('Test') and resource ('connection to Wiki.js'), and adds that it retrieves basic site information. It is distinguishable from siblings primarily through the 'connection status' framing, but it does not explicitly differentiate itself from wikijs_get_site_info, which likely overlaps in the 'basic site information' part.

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 wikijs_get_site_info, wikijs_workspace_status, or wikijs_repository_status. The description implies it is a connection health check, but it never states this should be used first or that it should be preferred over sibling tools for connectivity validation.

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. 'Create' implies mutation, but the description does not state what happens when a parent path does not exist, whether intermediate pages are auto-created, privacy/publish defaults, or any permission requirements. The single detail about hierarchy adds some context but leaves significant behavioral uncertainty.

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 verb and key differentiator front-loaded. There is no redundant wording, and it is appropriately short for its limited content.

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

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

Given the tool has 9 parameters, no output schema, and no annotations, the one-sentence description is not sufficient. It leaves unclear how parentPath behaves, what the resulting URL structure looks like, and how this tool fits into the broader workflow alongside the many sibling creation and management tools.

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 9 parameters are already documented in the input schema. The description adds no additional 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 clearly states the verb ('Create') and resource ('a page'), and the qualifier 'with hierarchical path structure' distinguishes it from the sibling wikijs_create_page, which presumably creates a flat page. However, it does not explicitly name the sibling or fully outline the tool's scope, so it stops short of a 5.

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

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

The hierarchical path language implies this tool is for creating nested pages under a parent path, especially given the required parentPath parameter. But the description does not explicitly contrast it with alternatives like wikijs_create_page or provide when-not-to-use guidance, leaving the usage guidance mostly 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?

With no annotations provided, the description carries the full burden of behavioral disclosure, and it only states a basic action. It does not disclose what happens if a page already exists at the given path (overwrite, error, skip), whether authentication or workspace context is required, or what the tool returns. For a mutating tool, this is a meaningful gap.

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

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

The description is a single efficient sentence with the core action front-loaded. There is no wasted wording, though 'with markdown content' is slightly redundant with the schema's own 'Page content in markdown format' parameter description.

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 9 parameters, no annotations, no output schema, and 21 siblings including several overlapping creation flows, this one-liner is insufficient. The schema covers parameters, but the description omits sibling-selection context and behavioral expectations (e.g., path collision behavior), which are the very gaps an agent needs filled in this complex tool landscape.

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 one of the 9 parameters (path, tags, title, editor, locale, content, isPrivate, description, isPublished) is already documented structurally. Baseline 3 applies; the description's 'with markdown content' adds only marginal reinforcement of the content/editor parameters and no new semantic meaning.

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

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

The description uses a specific verb-resource pair ('Create a new page in Wiki.js') that clearly distinguishes it from read, update, and delete siblings like wikijs_get_page, wikijs_update_page, and wikijs_delete_page. However, it does not differentiate from the close sibling wikijs_create_nested_page, which also creates pages; the agent cannot tell from the description alone which creation tool to pick.

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

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

The description gives zero guidance on when to use this tool versus the 21 siblings. No mention of when to prefer it over wikijs_create_nested_page (nested structure), wikijs_bulk_create_pages (multiple pages), or wikijs_sync_file_docs (file-based creation). Any usage inference must come from sibling names, not the 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 present, so the description must carry the behavioral disclosure burden. It only says 'create', leaving unknown whether the tool overwrites existing structures, creates pages or folders, requires an initialized repository, or returns any confirmation. This is insufficient for a mutating operation.

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

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

The description is a single front-loaded sentence with no wasted words. However, the word 'complete' is vague and does little to clarify the tool's actual behavior, so it is concise but not maximally 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?

With no output schema and no annotations, the description should explain what structure is created, how the parameters influence it, and what the caller receives. It does none of this, so an agent cannot predict the outcome of invoking the tool.

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

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

Schema description coverage is 100%, so every parameter is already documented in the input schema. The description adds no additional meaning about how repoName, description, sections, or basePath are used, 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 names a concrete action ('Create') and a resource ('repository documentation structure'), so it is not a tautology. However, it never defines what a 'complete' structure means or differentiates this from sibling scaffolding tools like wikijs_init_repository or wikijs_create_nested_page.

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 for when to use this tool versus alternatives such as wikijs_create_page, wikijs_bulk_create_pages, or wikijs_init_repository. The name implies repository-level setup, but the description provides no explicit context, prerequisites, or exclusions.

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

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

No annotations are provided, so the description carries the full burden of behavioral disclosure. The word 'Create' signals a write operation and suggests a persistent mapping, but the description gives no information about idempotency, duplicate handling, whether existing mappings are overwritten, or what valid relationship values are beyond the schema's loose examples.

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

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

The description is a single, front-loaded sentence with no unnecessary filler. It is concise and readable, though the brevity comes at the cost of behavioral and usage 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?

With no annotations, no output schema, and six required parameters, the description alone is insufficiently complete. It does not explain what the mapping means structurally, what happens when the tool runs, or how the result is represented, and it provides no usage context to guide correct invocation beyond the schema.

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

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

Schema description coverage is 100%, so the structured definitions already document all six parameters clearly. The description adds no additional meaning beyond the high-level idea of a mapping, so it does not go beyond the baseline expected when the schema is complete.

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: 'Create architectural mapping between repositories.' It is reasonably distinct from sibling page- and repository-creation tools because it emphasizes relationships between repositories. It is slightly underspecified because 'architectural mapping' is not elaborated, but the schema fills in the main entities.

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 wikijs_create_repo_structure or wikijs_create_page. The phrase 'between repositories' implies a cross-repository scenario, but the description does not state prerequisites, exclusions, or when another tool would be more appropriate.

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

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

With no annotations provided, the description carries the full burden of behavioral disclosure. It only states the core destructive action and omits critical context such as whether deletion is permanent, whether child pages or linked content are affected, or if any confirmation/permission is required. This is a significant gap for a mutation tool.

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

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

The description is a single, clear sentence with no wasted words. It is appropriately sized for a one-parameter tool and the core action is front-loaded, 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?

Despite the tool's low parameter complexity, it is a destructive operation with no annotations and no output schema. The description is too spare: it does not mention whether the deletion is reversible, what happens on success or failure, or any side effects on related content. More behavioral context is needed for an agent to invoke it safely and correctly.

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

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

The schema has 100% description coverage, so the baseline is 3. The description's 'by ID' merely echoes the schema's 'Page ID to delete' and adds no new meaning, such as the ID format, source, or behavior when the ID does not exist.

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

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

The description uses a specific verb ('Delete') with a clear resource ('a page') and method ('by ID'). This distinguishes it from sibling tools like wikijs_update_page, wikijs_get_page, and wikijs_create_page, since no other sibling deletes a page.

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

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

The description provides no guidance on when to use this tool versus alternatives such as wikijs_update_page, which might be used to deactivate or repurpose a page instead of deleting it. There are no stated conditions, prerequisites, or exclusions; usage is only implied by the verb 'Delete'.

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 explaining behavioral traits. It does not disclose whether detection is read-only, whether it requires an existing repository/workspace, what it does when context is absent, or what the returned context looks like. The word 'auto-detect' implies passive analysis, but important behavior remains unspecified.

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 sentence, no filler, and the core action is front-loaded. It is appropriately concise for a simple optional-directory tool, even though the content is somewhat underwhelming in depth.

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

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

The definition does not explain what 'context' means or what the tool returns, and there is no output schema to fill that gap. Given siblings like wikijs_get_context and wikijs_set_context_mode, more context about the detection result and its consumability would be necessary for an agent to reliably use 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?

The schema description covers 100% of the single parameter, so the baseline is 3. The tool description adds 'current directory' as the default scope, but it corresponds directly to the schema's 'defaults to current' and adds no further semantic 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 names a clear action ('auto-detect') and a specific resource ('repository and workspace context') scoped to a directory. It distinguishes itself as a detection tool from sibling tools like get_context or set_context_mode, though it doesn't explicitly contrast with them.

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

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

The phrase 'for current directory' gives some context, but there is no guidance on when to choose this over wikijs_get_context, wikijs_set_context_mode, wikijs_init_repository, or wikijs_init_workspace. No when-to-use or when-not-to-use conditions are provided.

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

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

No annotations are provided, so the description must carry the behavioral disclosure burden, but it only says 'Generate documentation overview.' It does not clarify whether the tool writes to Wiki.js, only analyzes the file, overwrites existing overviews, or what side effects, if any, 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 front-loaded sentence with no filler or repeated information. Every word contributes to the core purpose.

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

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

With no output schema and no annotations, the description needs to explain return behavior, side effects, and anticipated outcomes to be complete; it only states the core action. The tool's context among sync/create siblings is also left unexplained, leaving an agent without enough information to invoke it confidently.

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

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

Schema description coverage is 100%, with filePath, includeCode, and analysisDepth already documented in the input schema. The description adds no additional parameter context, 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 ('Generate') and resource ('documentation overview for a code file'), so an agent can tell it is about producing an overview of a single file. However, it does not distinguish this from nearby siblings such as wikijs_sync_file_docs or wikijs_smart_sync_file, so it stops short of the top score.

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

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

There is no guidance on when to use this tool instead of alternatives. The description does not mention prerequisites, naming the siblings that overlap with this capability, or conditions that would make another tool preferable.

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. It only adds that the information is 'current' and 'optimized for Claude consumption,' with no disclosure of side effects, state dependencies, or return characteristics.

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. The 'optimized for Claude consumption' qualifier hints at output format, though it is somewhat vague and does not earn full marks.

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

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

With no output schema and no annotations, the description should clarify what 'context information' includes and how mode affects the result. It leaves the response shape and the relationship to context-detection or status tools unexplained, though the simple one-parameter schema limits the 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 coverage is 100%: the single optional mode parameter is fully enumerated with a meaningful description saying it uses the current mode by default. The tool description adds no additional meaning to the parameter, so 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 clear action ('Get') and resource ('current context information'), so the agent recognizes it as a read-style retrieval. However, it does not distinguish this tool from siblings like wikijs_detect_context or wikijs_set_context_mode, and 'context' remains undefined.

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

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

No when-to-use guidance is provided. The description never contrasts this tool with wikijs_detect_context, repository_status, workspace_status, or set_context_mode, so the agent must infer selection from the name alone.

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

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

With no annotations provided, the description carries the full burden, but it only says 'Retrieve a page by ID or path'. It does not disclose return shape, what happens if both id and path are provided, what happens if neither is provided, or how path resolution behaves.

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

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

A single, front-loaded sentence with no wasted words. It states the verb, resource, and lookup keys efficiently.

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

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

Adequate for a simple two-parameter read tool, but the optionality of both parameters is ambiguous and there is no output schema or annotation to clarify expected return values. The description would benefit from stating that at least one of id/path should be provided and what the result contains.

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

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

Schema coverage is 100%, so the schema already documents both parameters. The description restates the lookup-by-ID-or-path idea but adds no new meaning such as precedence or exclusivity requirements.

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 the exact operation ('Retrieve a page') and the two lookup mechanisms (ID or path). This clearly differentiates it from sibling tools like list_pages, search_pages, create_page, and update_page.

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 instead of search_pages or list_pages, nor any mention of exclusions or context. The only implied usage is retrieving a known page, but that is not made explicit.

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

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

With no annotations, the description must carry the behavioral burden. 'Get' conveys a read-only operation, but the description does not disclose what information is returned, whether it requires a live connection, or whether any data is cached. For a zero-parameter read-only tool this is a modest but not severe 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, front-loaded sentence with no filler. It is appropriately concise, though 'detailed information' is somewhat imprecise and could have been more concrete without adding bulk.

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 is the only source of what the agent will receive. Saying 'detailed information' without listing example fields, scope, or relationship to sibling status tools leaves the agent unable to judge whether this tool answers a specific request.

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

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

The tool has no parameters, so parameter semantics are predominantly schema-defined. The empty schema already documents everything needed; the description does not need to add parameter 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 uses a clear verb and resource: 'Get detailed information about the Wiki.js instance.' It is reasonably distinguishable from sibling repository/workspace/connection status tools because it targets the overall instance, though 'detailed information' remains vague about what is included.

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 related status tools like wikijs_connection_status or wikijs_repository_status. An agent has 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?

No annotations are provided, so the description carries the full burden of behavioral disclosure. It only states that repository context is initialized, but does not explain side effects, whether it is idempotent, whether it creates files, modifies state, or requires an active Wiki.js connection.

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

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

The description is a single concise sentence with no filler or repetition, and the primary action is front-loaded. It is appropriately brief, though the brevity contributes to missing 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?

With no annotations, no output schema, and three optional parameters, the description leaves important operational questions unanswered: what does 'repository context' mean, what happens after initialization, and what return or confirmation should the agent expect? The tool is underspecified for reliable 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 schema already documents all three optional parameters clearly. The description adds no extra semantic detail, but it does not need to because the parameter descriptions already explain purpose and optionality.

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 ('Initialize') and a specific resource ('repository context for Wiki.js documentation'), making the core action clear. However, it does not meaningfully differentiate from sibling tools like wikijs_init_workspace or wikijs_set_context_mode, so it falls short of a 5.

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

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

The description provides no guidance on when to use this tool versus alternatives such as wikijs_detect_context, wikijs_init_workspace, or wikijs_set_context_mode. It only implies an initialization use case without stating prerequisites, pre-conditions, 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 provided, the description carries the full burden of explaining side effects and behavior. It only states that workspace context is 'initialized' without disclosing whether this writes files, updates state, requires permissions, or affects existing configuration. This is a significant transparency gap for an initialization tool.

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

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

The description is a single concise sentence and leads with the main action, which is structurally efficient. However, it is so spare that it omits behavioral and usage information an agent would need, so it is under-specified rather than optimally 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?

The tool takes only optional parameters and appears to rely on auto-detection, yet the description never clarifies what happens when parameters are omitted, what 'workspace context' contains, or what a successful initialization produces. With no annotations and no output schema, this one-sentence description is insufficient for a complex setup operation.

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

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

Schema description coverage is 100%, so the schema already documents each parameter. The description adds no parameter-level detail, but because the baseline is 3 for full schema coverage and the individual property descriptions are reasonably informative, no penalty beyond that is warranted.

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 ('Initialize workspace context') and a distinct scope ('multi-repository documentation'), which differentiates it from sibling tools like wikijs_init_repository. However, it does not explain what 'workspace context' concretely means, so the purpose is clear but not fully fleshed out.

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 'multi-repository documentation' implies this tool is for initializing a workspace spanning multiple repositories, and the sibling wikijs_init_repository suggests a single-repository alternative. There is no explicit when-to-use or when-not-to-use guidance, so the signal 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?

With no annotations provided, the description carries the full behavioral disclosure burden. 'List pages with pagination' does communicate a read-only enumeration operation and the existence of pagination, but it omits details like ordering, whether returned entries are summaries or full page content, and pagination edge behavior.

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

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

The description is a single, front-loaded sentence with no wasted words. It efficiently conveys the core operation and a key behavioral trait, even though it does not provide deeper detail.

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

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

For a simple two-parameter, no-required-fields tool, the description plus fully documented schema is mostly enough to invoke the tool. However, without an output schema and without any note about return shape, ordering, or the difference from search_pages, the description leaves some gaps for an agent deciding how to interpret the 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?

The input schema fully describes both limit and offset with defaults and meanings, so the schema carries the descriptive weight. The description's word 'pagination' only loosely parallels those parameters and adds no new constraints, ranges, or formatting details, warranting the baseline 3.

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 ('pages'), with a pagination qualifier that clarifies the operation's mode. It is clear but does not explicitly differentiate list_pages from sibling tools like wikijs_search_pages or wikijs_get_page, so it falls short of a 5.

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

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

No guidance is given about when to use this tool versus alternatives such as wikijs_search_pages or wikijs_get_page. The description states what the tool does but does not provide usage context, exclusions, or a decision rule for selection.

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

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

With no annotations, the phrase 'Show current...status' does convey a read-only, non-mutating operation, which is transparent at a basic level. But it adds no detail about what 'documentation status' includes, whether initialization is required, or what side effects might 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?

One short sentence that leads with the action verb and the object, with no filler or redundancy. It is appropriately sized for a simple status tool.

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

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

There is no output schema and no annotation to complete the picture, so the description should explain what the status output actually contains. It only offers the vague phrase 'documentation status' and does not cover prerequisites, expected return values, or how this relates to sibling status/context tools.

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

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

The tool has zero parameters, the schema is empty, and schema description coverage is 100%, so parameter semantics are trivially satisfied by the schema. The baseline for zero-parameter tools is 4.

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

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

The description uses the verb 'Show' and identifies the resource as current repository context and documentation status, so an agent can tell it is a status/read tool. However, it does not distinguish it from similar sibling tools like wikijs_get_context, wikijs_detect_context, or wikijs_workspace_status.

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

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

No guidance explains when to use this tool rather than the many sibling context/status tools. The description only implies a status-check purpose and gives no conditions, prerequisites, or alternatives.

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 does not mention matching semantics (partial, fuzzy, exact), case sensitivity, indexing lag, locale handling, or whether the operation is read-only. This is a meaningful gap for a search tool.

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

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

The description is one concise sentence that clearly communicates the core function. It is front-loaded and contains no filler or redundant phrasing relative to what the schema already provides.

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 relatively simple and parameters are fully documented in the schema, but the description offers no information about result format, search behavior, or when to use it among the many page-related siblings. It is minimally adequate but leaves gaps an agent would need to resolve.

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 query, path, and locale. The description adds no parameter-level detail beyond the schema, which aligns with the baseline score of 3 for high schema coverage.

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

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

The description states a specific verb ('Search'), resource ('pages'), and qualifier ('by text content'), making the core purpose clear. It does not explicitly distinguish itself from siblings like wikijs_list_pages, but the text-content qualifier provides reasonable 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?

No guidance is given on when to use this tool versus alternatives such as wikijs_list_pages or wikijs_get_page. There are no exclusions or conditions described, leaving the agent to infer the appropriate context from the 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 present, so the description alone must disclose behavior. It reveals only that the mode is switched; it does not state whether the change is persistent, affects subsequent operations, requires permissions, or returns a confirmation. This is thin disclosure for a state-changing tool.

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

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

The description is a single short sentence that front-loads the action and lists the accepted modes without any filler. Every word earns its place for this simple API.

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

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

Given the tool's simplicity, the schema plus description provide enough to make a correct call: one enum parameter with full schema documentation. However, with no annotations and no output schema, behavioral details like return value and side effects are absent, leaving the description only minimally complete.

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

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

Schema coverage is 100% and the single mode parameter already has an enum plus a descriptive label. The description merely repeats the three enum values and adds no additional meaning or usage syntax, so the baseline score of 3 applies.

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

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

The description uses a specific verb ('Switch') and resource ('context mode'), and enumerates the three valid modes, so an agent understands exactly what the tool operates on. It is clearly distinguishable from siblings like wikijs_get_context, wikijs_detect_context, and the initialization tools, even though no alternative is named explicitly.

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

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

The intended use is implied by the verb: use this tool when the current context mode needs to be changed. There is no explicit guidance about prerequisites (e.g., whether a repository/workspace must already be initialized) or when to prefer this over wikijs_detect_context or wikijs_get_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?

No annotations are provided, so the description carries the full burden of explaining behavioral traits. It mentions 'sync' and 'context awareness' but does not disclose whether the tool creates, updates, or overwrites pages, how it decides paths, whether it can be destructive, or what side effects occur. The behavior is too vague for an agent to predict the operation's impact.

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 redundant structure. However, the words 'intelligently' and 'context awareness' are vague buzzwords that could be replaced with more concrete behavioral detail without adding 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?

For a tool with no annotations, no output schema, and a nontrivial 'smart sync' behavior, the description is too sparse. It does not explain what context awareness means, how autoPath and forceUpdate affect behavior, or how this tool differs from the related sync_file_docs sibling. An agent would need to inspect external documentation to call it confidently.

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

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

Schema description coverage is 100%, so the schema already documents the three parameters. The description's 'using context awareness' loosely aligns with the autoPath parameter but adds no real semantic detail beyond what the schema provides. 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 clear verb and resource: 'sync file with Wiki.js.' It adds 'intelligently' and 'context awareness' to hint at a distinguishing behavior, but it does not precisely define what intelligence or context awareness means. It is distinguishable from create/update/list tools, but not clearly from the sibling wikijs_sync_file_docs.

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

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

The description provides no guidance on when to use this tool versus alternatives like wikijs_sync_file_docs or wikijs_create_page. There are no stated exclusions, prerequisites, or conditions for choosing this smart sync over a normal sync. The intended usage context is left entirely to inference.

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

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

With no annotations provided, the description carries the full burden of behavioral disclosure, and 'Synchronize' is opaque about side effects. It does not say whether existing wiki content is overwritten, merged, or preserved, whether missing pages are created, or what 'extract and format code content' (per the extractContent param) does to synced content. For a mutating 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?

Six words, no filler, and the core purpose is front-loaded. The single sentence is genuinely efficient; the shortfalls lie in what is missing rather than in what 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?

For a 4-parameter sync tool with no annotations and no output schema, this is under-specified. Missing are the sync direction, create-vs-update behavior, overwrite semantics, and the distinction from wikijs_smart_sync_file — all of which an agent needs to avoid destructive mistakes on wiki content.

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 four parameters are already documented in the schema and the baseline of 3 applies. The description adds only the general framing that file content maps to a wiki page — useful orientation, but no per-parameter meaning beyond what the schema provides.

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

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

The description states a clear verb ('Synchronize') and resource ('file content with Wiki.js documentation'), so an agent grasps the basic operation. However, it does not differentiate from the sibling wikijs_smart_sync_file, and the direction of sync (file-to-wiki vs bidirectional) is ambiguous.

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

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

There is no when-to-use guidance whatsoever. The description never mentions when to prefer this tool over wikijs_smart_sync_file or wikijs_update_page, nor does it state prerequisites such as an existing page or initialized repository. An agent must guess the appropriate context for invoking it.

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 an existing page', which restates the tool's name and does not clarify partial-update semantics, whether missing optional fields are overwritten, authentication needs, or what happens if the page does not 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, front-loaded sentence with no filler words. It is efficient and easy to parse, though it is also minimal and relies heavily on schema and sibling names for full 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 straightforward update operation, the schema covers all seven parameters and the description conveys the core purpose. However, with no annotations, no output schema, and no mention of return behavior or partial-update effects, the description is only minimally adequate rather than 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%, so the parameter meanings are already fully documented in the input schema. The description adds no supplementary parameter context, but the baseline score of 3 applies because the schema handles the heavy lifting.

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

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

The description states a clear verb ('Update') and resource ('existing page in Wiki.js'), which makes the core purpose immediately understandable. The word 'existing' distinguishes it from creation tools like wikijs_create_page, though it does not explicitly name sibling 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 this tool should be used when an existing Wiki.js page needs modification, but it does not give explicit when-to-use or when-not-to-use guidance. It does not mention that creating new pages should use wikijs_create_page or that deletions should use wikijs_delete_page, 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?

With no annotations provided, the description must carry the burden of behavioral disclosure. It says 'Show', implying a read-only operation, but does not state whether this is safe/non-mutating, what kind of response is returned, or whether there are side effects. It provides minimal behavioral information.

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 entire description is one concise sentence with no filler. It front-loads the action and clearly identifies the resource and scope. 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 parameterless status tool, the description states the basic scope and outcome, but it does not clarify what 'workspace context' includes, what counts as a repository status, or how this differs from the sibling repository_status tool. No output schema exists, so a bit more context would help an agent call it confidently.

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

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

The tool has zero parameters and 100% schema description coverage, so there is nothing meaningful to document. The baseline of 4 is appropriate because the description need not compensate for any missing parameter 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 names a specific verb and resource: 'Show workspace context with all repositories and their status'. It states a clear scope of workspace context across all repositories. However, it does not explicitly distinguish itself from the sibling wikijs_repository_status, which likely has a closely related purpose.

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 direct guidance about when to choose this tool over wikijs_repository_status, wikijs_get_context, or wikijs_detect_context. The description merely states what the tool does, leaving the agent to infer usage context without exclusions or alternatives.

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