Arbo

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

With no annotations, the description carries the full behavioral burden, but it only says 'create' and gives a use case. It fails to disclose whether the call appends to or replaces existing nodes, how seo.status values like keep/redirect/delete are honored, or what happens on partial failure. This is a meaningful gap for a bulk 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?

Two sentences, with the core action front-loaded and the use case in the second sentence. Every phrase adds information and there is no filler or repetition of schema 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?

Given the deeply nested nodes schema and the absence of an output schema or annotations, the description is too thin to be fully actionable. It does not explain return values, error behavior, or how the tool treats existing pages vs new pages. The agent can infer field semantics from the schema but not the overall execution model.

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 documents all parameters with 100% coverage, so the description is not required to restate them. It adds useful conceptual context by linking the tree structure to temp_id/parent_temp_id and mentioning zoning, entry points, CTAs and tags, which map to schema properties. This justifies the baseline score 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 ('Create multiple pages') and resource ('tree structure'), and immediately conveys the bulk nature that separates it from create_node. The mention of sitemap, zoning, entry points, CTAs and tags clarifies what kinds of nodes are expected. Minor ambiguity between 'pages' and 'nodes' is not enough to obscure the 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?

The phrase 'Create multiple pages at once' signals the batch use case, and 'Ideal for generating a full sitemap' gives a concrete scenario. It does not explicitly name alternatives like create_node for single-node creation or say when not to use it, so it stops short of full routing guidance.

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

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

With no annotations provided, the description carries the full burden. It discloses that the tool supports rich data structures (zoning blocks, entry points, CTAs, tags), which is useful context beyond the bare 'add a page'. However, it does not mention mutation side effects, idempotency, required authentication, or what happens to related resources, though these are less critical for a straightforward 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 sentences with zero filler: the first states the core action and the hierarchy parameter, the second enumerates the advanced data capabilities. The most important scoping information is 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?

Despite the tool's complexity (14 params, nested objects, no output schema), the description covers the essential purpose and highlights the non-obvious rich-data capabilities. The schema handles detailed parameter semantics, and the description does not need to explain return values for a create operation. It is slightly incomplete regarding edge cases (e.g., what 'Add' implies for existing pages), but it provides enough for an agent to decide to invoke 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 the baseline is 3. The description adds conceptual grouping by calling out zoning_blocks, entry_points, cta, and tags as 'rich data', but it does not add format, syntax, or optionality details beyond what the schema already documents. It provides mild extra meaning but does not compensate for any gaps since none 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-resource pair ('Add a page to a project's sitemap'), immediately distinguishing it from siblings like create_project, update_node, and delete_node. It also names the key hierarchy mechanism (parent_id) and the rich-data capabilities, making the tool's purpose unmistakable even 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 gives one explicit usage instruction ('Use parent_id to create hierarchy') and implies single-page creation, but it never states when to prefer create_node over bulk_create_nodes or update_node. No alternatives or exclusion criteria are provided, leaving the agent to infer the boundary between single and bulk creation.

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. It discloses the return value ('Returns the project ID') and implies a side effect (creating a resource), but does not address permissions, idempotency, duplicate-name handling, or failure behavior. The return-value disclosure adds genuine context beyond the name, though the safety profile remains underexplained 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?

Three short sentences deliver the purpose, the return value, and the next workflow step with zero wasted words. Each sentence earns its place and the core action is front-loaded.

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 3-parameter creation tool with full schema coverage and no output schema, the description covers the essentials: what it does, what it returns (project ID, which output schema would otherwise convey), and the logical next step. Minor gaps exist around error conditions and prerequisites, but nothing an agent needs to invoke it successfully 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%, with all three parameters (name, accent, client) already documented in the input schema. The description adds no parameter-level detail beyond what the schema provides, which matches the baseline of 3 for high coverage.

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

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

The description uses a specific verb ('Create') with a clear resource ('a new project'), and it differentiates from sibling tools by explicitly naming create_node as the follow-up step for adding nodes. The workflow relationship to bulk_create_nodes and create_node is evident, so an agent can tell this tool apart without opening schemas.

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

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

The description implies usage by stating 'Add nodes with create_node after,' which signals the correct sequencing (create project first, then nodes). However, it never explicitly states when to choose this tool over alternatives, nor excludes cases like bulk project creation or when get_project/list_projects 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, the description must carry the behavioral burden. It does disclose a key side effect: the delete is soft and reversible via version history. However, it does not describe the effect on child nodes, potential permissions, or what response the caller should expect.

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

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

The description is one tightly worded sentence that front-loads the action before the qualifier. There is no redundant phrasing or filler.

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

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

The schema covers parameters and the default cascade behavior, and the description adds the soft-delete/restore context. Still, because there is no output schema and no annotations, an agent gets no information about return values, error conditions, or permissions, so the description is only minimally complete for a mutation 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 the parameters (project_id, node_id, cascade) are already fully documented in the schema. The description adds no parameter-level meaning beyond the schema, which is acceptable but not value-adding.

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 ('Remove') and resource ('a page from the sitemap'), and the parenthetical clarifies the operation is a soft delete. This makes it immediately clear what the tool does and how it differs from siblings like create_node and update_node.

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 statement of when to use this tool versus alternatives, no prerequisites, and no mention of when to set the cascade option. The intended use is only implied by the name and the verb 'Remove'.

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 behavioral disclosure. It reveals the side effect (saved to zoningHtml), the prerequisite, and the cost. It does not mention overwrite behavior or error handling, but core transparency is good.

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 main action is front-loaded, followed by the side effect, prerequisite, cost, and return value in logical order. Every clause 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 simple two-parameter tool with no output schema, the description covers the essential contract: what it generates, where it saves, the prerequisite, cost, and return value. It could additionally explain failure behavior or how zoning blocks are obtained, but those are secondary.

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 baseline is 3. The description adds meaningful context by tying node_id to the requirement that zoning blocks exist and clarifying that output is stored in zoningHtml, going beyond the plain schema descriptions.

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 ('generate') and resource ('lo-fi wireframe HTML') plus the target storage field (zoningHtml). This clearly distinguishes it from sibling node management tools like create_node or update_node.

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 context: a prerequisite (zoning blocks must be defined) and a cost condition (1 AI credit or BYOK). However, it does not name alternative tools or explicitly state when not to use it, so it falls just short of full routing guidance.

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

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

With no annotations provided, the description carries the full burden of behavioral disclosure. It states that it 'gets' a project, which implies a read operation, but does not explicitly mention that it is read-only, what happens if the project_id is invalid, or any authentication requirements. The phrase 'full sitemap tree' indicates the return content, but other 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, focused sentence that states the core action and the key output detail. There is zero wasted wording, and it is appropriately front-loaded with the verb and resource. It is concise without being 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 simple getter with one parameter and no output schema, the description tells the agent what it returns (the project with its full sitemap tree), which is the essential information needed to call it. It does not describe error conditions or response formatting, but given the simplicity and that the return content is stated, it is largely complete. A slight gap is the lack of explicit read-only assurance, but that is minor.

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 documents project_id with a minimal description ('The project ID'), and the schema coverage is 100%. The tool description adds no additional meaning about the parameter format, type constraints, or how it is used. Since the schema covers the parameter, the baseline is 3, and the description does not enhance 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?

The description clearly states the verb 'Get' and the resource 'project', with the specific detail 'full sitemap tree' that distinguishes it from list_projects (which likely lists summaries) and create_project (which creates). This is unambiguous and specific enough for an agent to know exactly what it 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?

The description provides no guidance on when to use this tool versus alternatives. It does not mention that this is the right choice when you need the complete sitemap tree, nor does it contrast with list_projects or create_node. The usage context is entirely implied by 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 provided, so the description must carry the full burden. It states that the operation is read-only in effect ('List') and implies no side effects, which is important behavior. It also adds the token-scoping constraint, indicating it operates within the token's permissions. However, it doesn't detail output format or pagination, which could be relevant, but for a simple list operation the core behavior is clear.

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 wasted words. It front-loads the verb and resource, and clearly communicates the tool's purpose and scope without redundancy.

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

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

Given the tool's simplicity (zero parameters, no output schema), the description is complete enough for an agent to call it correctly. It clearly states what it does and the scope. Minor gaps, such as details about the return format or pagination, are not critical for a simple list 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?

The tool has zero parameters, and the schema is empty. The description doesn't need to explain any parameters. The score of 4 aligns with the baseline for zero parameters, as no compensation is required.

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 ('projects') and clarifies the scope ('accessible with this token'). It is clear and distinguishes from sibling tools like create_project or get_project. However, it doesn't explicitly contrast with the sibling get_project, which also deals with projects, though 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 description implies usage: use this to list projects, but it does not explicitly state when to use it versus alternatives. It doesn't mention when not to use it or point to siblings like get_project for a single project. There's no guidance on scenarios like filtering or pagination.

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

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

No annotations are provided, so the description carries the full behavioral burden. It does disclose that description supports real newlines and no length limit, and that zoning_html replaces the current wireframe. However, it does not state that update is a mutation (though implied), nor does it mention merge behavior for the SEO block, which is only in the schema. More behavioral detail (e.g., what happens to previous content) would be helpful.

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 relatively concise and front-loaded: it starts with the core purpose and then highlights key specialized fields. It is three sentences, no fluff, and each sentence adds value (newline handling, rich content, zoning_html, annotations). Minor deduction for not being ultra-structural, but it's 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?

Given the tool's complexity (12 parameters, nested objects, no output schema), the description is not fully complete. It explains the most nuanced parameters (description, zoning_html, annotations) but leaves out important details like merge semantics for SEO, how parent_id moves work, and what exactly 'New page type' means. It covers the essentials but gaps remain for an agent to call it correctly in all scenarios.

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 75%, and the description adds meaning primarily for the 'description' and 'zoning_html' parameters, emphasizing real newlines and wireframe replacement. However, the description does not elaborate on many other parameters like 'annotations', 'notes', 'rationale', or 'parent_id' beyond what the schema already describes. It adds some value, but not fully compensating for the 25% gap, so 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 clearly states that the tool updates a page's properties, a specific verb-resource pairing. It highlights key fields and content capabilities (description, zoning_html, annotations), which helps distinguish it from creation tools like create_node. However, it does not explicitly differentiate itself from other update-related tools in the sibling list (there are none), so a small deduction.

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

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

The description does not explicitly state when to use this tool versus create_node or bulk_create_nodes. It is implied that updates are for existing nodes, but there is no direct guidance such as 'use for modifying existing pages, not creating new ones'. The rich content mention suggests use cases, but clear context for when not to use is missing.

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