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

No annotations are provided, so the description carries the full behavioral disclosure burden for a mutation tool. It usefully says the lane is appended to the right-hand end, but omits permissions, project-existence requirements, side effects, and response 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?

It is a single front-loaded sentence with no wasted words. The core action and placement are stated immediately.

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 is minimally sufficient to invoke it. However, with no annotations and limited parameter explanation, it leaves gaps around mutation behavior and the name parameter.

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 only 50%; project is described as an id or name, but name has no descriptive field. The description implies that a lane is added to a project but does not explain the name parameter's meaning, uniqueness, or constraints beyond the schema's minLength.

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 (Add), resource (lane), and location (right-hand end of a project). It clearly differentiates creating a new lane from the sibling rename_lane operation.

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

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

The phrasing implies this is used when adding a new lane to a project, but it does not state prerequisites, exclusions, or explicitly point to rename_lane for modifying an existing lane. Usage is implied rather than guided.

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, and it does disclose two useful traits: append-at-bottom ordering and the default lane. It omits what happens with an unknown lane name, what the call returns (the created task?), and any permission or auth requirements for a mutation.

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

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

Two short sentences, zero filler, with the core action and the most surprising behavior (lane default) both 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 six-parameter creation tool with no annotations and no output schema, the description covers the one non-obvious behavior (default lane and insertion position). Requirements like project/title are enforced by the schema's required list, so little 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 coverage is 67% and the description reinforces the lane default, while the placement wording ("bottom") adds ordering semantics the schema does not express. Remaining parameters (title, labels, body) are self-evident or schema-documented, so the baseline applies.

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

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

States a specific verb and resource ("Add a task") plus the placement rule ("to the bottom of a lane"), which is genuinely distinguishing information. It does not explicitly contrast with siblings like update_task or create_lane, though the name makes the distinction reasonably obvious.

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 only guidance is the lane fallback ("Defaults to the first lane"), which describes default behavior rather than when to choose this tool over update_task or move_task. Usage is implied by the name rather than stated.

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

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

Annotations already declare destructiveHint=true, so the write/destructive nature is covered. The description adds meaningful scope context with 'for everyone', clarifying this is a shared/global removal rather than a personal view change. It stops short of stating irreversibility, permission requirements, or whether dependent items (assignments, comments) are affected.

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 nine-word sentence with zero filler, and the shared-impact qualifier is front-loaded. Nothing to trim.

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

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

For a single-parameter tool with a fully documented schema and a destructiveHint annotation, the description covers what it does and its blast radius ('for everyone'). What remains missing (irreversibility, ambiguity handling on title input) is minor for this complexity level.

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

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

Schema coverage is 100% with one documented parameter ('Task id or exact title'), so the schema already carries the semantics. The description adds nothing about resolution rules when a title is ambiguous or fuzzy-matched, so baseline 3 applies.

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

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

States a specific verb ('Remove') and resource ('a task') with scope ('from the board for everyone'), so an agent immediately understands the operation. It doesn't reference any sibling (e.g., update_task vs delete_task boundaries), keeping it below a 5.

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

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

There is no when-to-use guidance, no mention of when to prefer update_task or a soft-close alternative, and no prerequisites. The agent must infer usage purely from the verb.

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

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

Annotations already declare readOnlyHint=true, and the description adds real behavioral detail beyond that: ordering guarantees for lanes and tasks, and that task bodies are stripped, which prevents an agent expecting full task content. It stops short of describing other returned task fields.

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 terse sentences with zero waste, front-loading the return shape and then the routing caveat. 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?

There is no output schema, yet the description conveys the return shape (ordered lanes containing ordered tasks) and an important omission (no bodies), which is enough to call it correctly. It could say slightly more about what task fields are included beyond bodies.

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 'project' parameter is documented as 'Project id or name,' so the schema does the heavy lifting. The description implies project scoping but adds no format or resolution detail beyond the schema; 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?

States a specific verb+resource and scope: returns 'every lane of a project in order, with its tasks in order.' It also explicitly distinguishes itself from sibling get_task by noting bodies are omitted, so an agent can route 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?

Names the alternative explicitly with the condition that selects it ('use get_task for one') because bodies are omitted here. This covers the main when-to-use decision, though it doesn't address relation to list_projects (overview vs. one board).

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?

readOnlyHint=true already tells the agent this is a safe read, so the description's added value is mainly the return-content hint: the markdown body and lane are included. It does not say what happens when no task matches, whether a prefix match can be ambiguous, or how the payload is shaped (there is no output schema).

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

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

One compact sentence with zero filler, and the most informative clause ('including its markdown body and lane') is placed early. It is borderline under-specified rather than bloated, so it earns high but not top marks on structure.

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

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

For a one-parameter read tool with full schema coverage and a readOnly annotation, the description covers the essentials. However, with no output schema it should do more to characterize the returned task payload and the not-found behavior, which are the two things an agent would still wonder about.

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 'task' parameter is fully documented in the schema, including the id/6+ character prefix/exact title forms. The description adds nothing about the parameter, 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 the resource ('one task') and the fidelity of the result ('in full, including its markdown body and lane'), which distinguishes it from list-style siblings. The verb is carried only by the tool name/'Get task' title rather than the description, and it never contrasts itself with siblings like get_board or update_task.

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

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

There is no statement of when to use this tool, when not to, or what the alternative is (e.g., a list/search tool). An agent must infer from the name alone that this is the single-item retrieval path, and the useful detail that 'task' accepts an id, a 6+ char prefix, or an exact title lives entirely in the schema.

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

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

The readOnlyHint annotation already establishes the safety profile. The description adds useful return behavior by saying results include roles and usable assignee names, but it does not cover pagination, ordering, or authentication context.

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

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

Two short sentences with no wasted wording, front-loading the resource and then adding the practical usage note. Both sentences earn their 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 read-only tool with one optional parameter and no output schema, the description is largely complete: it says what is returned and how the names are used. It could be improved by mentioning pagination or result ordering, but those are minor gaps given the tool's simplicity.

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 company parameter and its optionality are already fully documented in the schema. The description does not add syntax or filtering details beyond what the schema provides, so the baseline of 3 applies.

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

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

The description clearly identifies the resource and scope: people in a company, including their roles. It is specific enough to distinguish from task-oriented siblings and from whoami, but it does not use an explicit retrieval verb or explicitly name how it differs from sibling tools.

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

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

It gives a clear usage context: use the returned names as task assignees. It does not state when not to use it or name alternatives such as whoami, but the intended use case is 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?

readOnlyHint=true already tells the agent this is a safe read, so the bar is lower. The description does add real value beyond the annotation by disclosing result scoping (only projects visible to this agent) and the payload contents (lane and task counts, which matters since there is no output schema), but says nothing about ordering, pagination, or empty-list 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?

A single front-loaded sentence with no filler, and the scoping constraint leads ahead of the return contents. It is efficient, though it is a fragment that leaves the list/aggregate nature of the operation implicit.

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

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

For a zero-parameter read tool with a readOnly annotation and no output schema, the description carries the essential information: what is listed, whose visibility governs it, and what extra aggregates come back. Only ordering and pagination details are missing, which is minor here.

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 takes zero parameters, so the baseline of 4 applies. The schema is an empty object and the description correctly describes only the scope and return contents rather than inventing filtering options that do 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 sentence names a specific resource (projects) and a concrete scope (projects this agent can see), plus what comes back (lane and task counts). It is easily distinguished from the sibling tools, which all operate on boards, tasks, lanes, or people rather than the project list, though it never explicitly contrasts itself 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?

Usage is only implied: an agent can infer this is the entry point for enumerating projects before drilling into get_board or get_task. There is no explicit when-to-use statement, no mention of alternatives, and no 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?

With no annotations, the description carries the full burden for a mutation tool and discloses almost nothing about side effects: what happens to the positions of other tasks in the source/destination lane, whether the operation is atomic or idempotent, or what permissions are needed. The position default it mentions is already declared in the schema.

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

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

A single sentence with the primary action front-loaded and the two modes packed into a parenthetical. Nothing is wasted and nothing is buried.

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 three-parameter mutation with full schema coverage and no output schema, the description covers the core action and both modes adequately. The remaining gap is behavioral (side effects on surrounding tasks), not structural.

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 all three parameters are documented in the schema itself. The description adds one genuinely useful nuance — that lane may be the task's existing lane, turning the call into a reorder — which is the correct baseline-plus value.

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

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

"Move a task" names a specific verb and resource, and the parenthetical "(or reorder within one)" distinguishes the two modes the tool supports. It does not, however, distinguish itself from sibling update_task, which an agent might reasonably guess also changes a task's lane.

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

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

Usage is only implied: the parenthetical suggests you can pass the task's current lane to reorder, but there is no explicit "use this instead of update_task" guidance, no prerequisites, and no failure conditions described.

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 for a mutation tool. It identifies the operation as a rename but says nothing about permissions, whether the old name remains valid, collision behavior, reversibility, or what happens to existing references.

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

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

The single sentence is front-loaded and free of fluff, so it is appropriately concise. However, it is under-specified for a three-parameter mutation tool rather than genuinely complete.

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 one parameter undocumented, the definition is too thin for a mutation operation. An agent lacks information about permissions, failure modes, and the meaning of the new name parameter.

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 only 67%: project and lane are documented in the schema, but name has no description and the description adds no parameter meaning beyond restating the operation. It does not explain format, constraints, or how "name" differs from the lane identifier.

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 ("Rename a lane") and adds scope ("in a project"), which lets an agent distinguish it from create_lane and other sibling tools. It is clear but does not mention any distinguishing conditions beyond the basic operation.

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

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

There is no guidance on when to use this tool versus alternatives, no prerequisites, and no exclusions. The agent must infer that this is the tool for changing an existing lane's name rather than creating or deleting one.

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 and does disclose key behavior: omitted fields are preserved (partial update), body/labels are whole replacements, and empty-string assignee unassigns. It does not cover permissions, idempotency, or what happens when the task is not found.

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

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

Three short sentences, front-loaded with the mutable-field summary, followed by the partial-update rule and the unassign edge case. No filler.

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

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

For a 5-param mutation tool with no annotations and no output schema, the description covers replacement semantics, partial updates, and the unassign sentinel well. Missing pieces are error behavior and return shape, which are secondary but non-trivial for a write 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 coverage is already 80%, so baseline is 3; the description adds the collective semantic that only supplied fields are mutated, which the per-property schema text does not state. The empty-string unassign hint is echoed from the schema, so marginal extra value there.

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 (change) and resource (task) plus the exact fields mutable: title, body, labels, assignee. This clearly separates it from siblings like create_task, delete_task, and move_task, though it never names those alternatives 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?

'Fields left out stay as they are' implies this is the partial-update tool, but there is no explicit when-to-use/when-not guidance and no routing away from move_task for lane changes or delete_task for removal. Usage is inferred from the name and field list.

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

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

readOnlyHint=true already establishes the safety profile, so the description only needs to add context. It does say the response covers identity, relay status and companies, and that it explains access granting, but it never details what 'relay status' contains or what the access-granting guidance looks like. With no output schema, this is 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?

Two short sentences with no filler, and the primary payload (identity, relay status, companies) is front-loaded before the secondary access note.

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

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

For a zero-parameter, read-only introspection tool this covers the essentials: what it returns conceptually and why it might matter (access). With no output schema the description carries the return-value burden, and it names the three data categories, though it could say more about response shape.

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

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

The tool takes zero parameters, so there is nothing for the description to disambiguate. Baseline 4 applies.

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

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

The description names a specific resource set – Nostr identity, relay status, and company memberships – which an agent can immediately distinguish from the sibling tools (list_projects, list_people, get_task, etc.). The verb is implicit ('returns/describes') rather than stated, which keeps it just below 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?

'Explains how to grant access if it has none' implies a useful trigger condition (call when lacking access), but the description never states explicitly when to call this versus the other list/get tools, and offers no exclusions. Usage is inferable but not directed.

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