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 says 'update' but omits whether the operation is reversible, what permissions it needs, how partial failures across the project list are handled, and whether the change is immediate or queued. For a batch mutation with zero annotation coverage 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?

One compact sentence with the operation front-loaded and no filler. It is well-sized, though it is so terse that it omits useful context rather than being wasteful.

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 batch mutation with a nested object, no annotations, and no output schema, the description should clarify batch semantics (partial failure behavior, limits) and permission requirements. It leaves an agent without enough to invoke it confidently in edge cases.

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

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

Schema coverage is 100%, so the schema already documents projectIds (array of UUIDs) and computeProfile ({ image, size }). The description's 'kernel image/size' phrasing loosely corroborates the nested object but adds no format, validation, or defaulting detail beyond the schema. Baseline 3 applies.

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

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

The description states a specific verb (batch update) and resource (kernel image/size, i.e. compute profile) scoped to multiple projects, so an agent can identify the operation. It does not explicitly contrast with sibling mutation tools like hex-update-project, but the 'batch' + 'compute profile' framing is distinctive enough.

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 over single-project alternatives, no prerequisites, no exclusions. The word 'batch' implies multi-project use but the description never says when this is preferable to updating projects individually.

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 signals a mutation and hints at a state constraint via 'active', but says nothing about reversibility, idempotency, whether partial results/outputs survive, permission requirements, or what happens if the run is already finished.

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 six-word sentence with the verb front-loaded and zero filler. It is efficient, though its brevity is partly under-specification rather than disciplined concision.

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

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

For a mutation tool with no annotations, no output schema, and 0% parameter description coverage, the description is too thin: it omits permissions, failure modes, effect on the run's outputs, and where the two IDs come from. The absence of structured fields elsewhere means the description should be doing far more work.

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 0%, so the schema supplies bare string types for projectId and runId with no format, source, or example. The description's phrase 'an active project run' only loosely restates that a project and a run are involved, adding essentially no meaning beyond the parameter names.

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 (cancel) and resource (project run) plus a state qualifier (active), so the agent knows this terminates a run rather than starting or inspecting one. It does not name or contrast the closely related siblings hex-run-project, hex-get-run-status, or hex-get-project-runs, which keeps it out of 5 territory.

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 when-to-use guidance, no statement of prerequisites (e.g. that the run must be in a cancellable state), and no routing advice relative to hex-get-run-status or hex-get-project-runs. The agent must infer that the 'active' qualifier is a precondition rather than a stated 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?

No annotations are provided, so the description carries the full behavioral burden. It hints that the target must be 'idle' but does not say what happens if the thread is not idle, whether this blocks or streams, what permissions are needed, or what the call returns. For a mutation-style tool with zero annotation coverage this is thin.

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

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

A single tight sentence with the action and target front-loaded; nothing is wasted. It is efficient but borders on under-specification rather than being genuinely concise by design.

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 2-parameter tool with no annotations and no output schema, the description should carry the behavioral and parameter burden. It explains the basic action but omits error/edge behavior (non-idle threads), threadId meaning, and any return context, leaving meaningful gaps.

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%: 'prompt' is described ('Follow-up prompt') but 'threadId' has no description at all. The tool description adds no syntax, format, or constraint details for either parameter, so it fails to compensate for the gap it should fill.

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 ('send a follow-up prompt') and resource ('agent thread'), making the action unambiguous. It implicitly narrows scope with 'idle' and 'follow-up', but never names the closest siblings (hex-create-thread, hex-get-thread-messages) to sharpen the distinction.

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

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

The word 'idle' signals the prerequisite condition (the thread must be idle) and 'follow-up' implies an existing thread, which is useful context. However, there is no explicit when-to-use guidance or contrast with hex-create-thread for starting a new thread versus continuing 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 behavioral burden. It discloses one useful trait — the cell is created in the draft version, not a published one — but says nothing about required permissions, what happens on cellType/source conflicts, or what the tool returns after 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?

A single front-loaded sentence with no filler, and the important scope qualifier ('draft version') comes before the tool is called. It is efficient, though terse enough that it underspecifies rather than being 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?

For a 4-parameter mutation tool with no annotations and no output schema, the description is thin: parameters are fully covered by the schema, and the draft-version scoping is disclosed, but prerequisites, permission needs, and post-create state are omitted.

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 (projectId, cellType enum, source, afterCellId) are already documented in the schema, setting the baseline at 3. The description adds no syntax, format, or defaulting detail 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?

States a specific verb and resource ('Create a new cell') and scopes it to the draft version of a project, which distinguishes it from hex-update-cell and hex-delete-cell among siblings. It does not explicitly name a sibling alternative, but the create/draft framing makes its role 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?

No when-to-use guidance, no prerequisites (e.g., the project must exist and have a draft version), and no routing to alternatives such as hex-update-cell or hex-list-cells. The only usable cue is the implied 'create' semantics.

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 behavioral burden but discloses nothing beyond 'create'. It does not say what permissions are required, how duplicate names are handled, whether 'members' is optional, or what the tool returns. For a mutation tool with a nested sharing object this is a significant gap.

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

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

A single front-loaded sentence with no wasted words, which is structurally sound. However, the brevity reads as under-specification rather than economy for a mutation tool with a nested object parameter.

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?

A write tool with no annotations, no output schema, three parameters, and a nested sharing object needs more than one sentence. Nothing is said about permissions, side effects, sharing semantics, or the result of the call.

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 description adds zero parameter meaning beyond the schema. With 67% coverage the schema documents 'name' and hints at the nested 'members' sharing shape, but the 'description' parameter is undocumented in both places, and the description never clarifies required vs optional or the semantics of the sharing config.

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

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

The description states a specific verb (create) and resource (collection) with its location (workspace), so the agent knows exactly what operation is performed. It is clear but does nothing to distinguish it from near-siblings like hex-edit-collection, hex-get-collection, or hex-create-group, so it stops short of 5.

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

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

There is no guidance on when to use this versus hex-edit-collection (modify an existing collection), hex-create-group, or the collection-sharing siblings. No prerequisites, no conditions, no exclusions are given.

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

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

No annotations are provided, so the description carries the full behavioral burden. It states only that a connection is created in the workspace; it says nothing about required permissions, whether the connection is immediately usable, what happens on duplicate names, or what is returned.

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

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

A single efficient sentence, front-loaded and free of waste. It is concise, though arguably too terse for a 4-parameter mutation tool.

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

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

For a mutation tool with no annotations, no output schema, and a nested type-dependent object, the definition is under-specified. It omits auth requirements, duplicate handling, and the shape of connectionDetails that the agent must supply.

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 75%, and the description adds no parameter meaning at all. The type-specific nested 'connectionDetails' object is the most error-prone input and neither the schema nor the description explains its per-type shape, so the description fails to compensate for the gap.

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 ('Create a new data connection') and the scope ('in the workspace'), which distinguishes it from siblings like hex-get-data-connection, hex-list-data-connections, and hex-edit-data-connection. It doesn't explicitly name those siblings, but the verb makes the distinction clear enough.

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, no prerequisites, and no mention of alternatives such as hex-edit-data-connection or hex-update-data-connection-schema. The agent must infer that creation happens before editing.

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 disclosure burden. It does not say whether this requires admin rights, whether the group name must be unique, whether members are optional, or what happens on duplicate names. For a mutation tool with zero annotation coverage, this is a significant gap.

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

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

A single front-loaded sentence with no waste. It is efficient, though arguably too terse given the tool's mutation semantics.

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

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

The tool is simple (2 params, 1 required, no output schema), so the description is minimally adequate. However, with no annotations and a nested members object, it should say more about the member format and expected return.

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 2 parameters, so the schema already documents 'name' and the nested members shape. Baseline 3 applies; the description adds no extra parameter meaning beyond the schema.

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

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

States a specific verb and resource ('Create a new group'), which clearly distinguishes it from hex-list-groups, hex-get-group, hex-edit-group and hex-delete-group. It does not explicitly name siblings, but the CRUD verb makes the intent 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?

There is no guidance on when to use this versus hex-edit-group or hex-delete-group, no prerequisites, and no note about required permissions. The description gives only what the name already implies.

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 but discloses almost nothing behavioral: it does not state that the URL is time-limited (schema default 15000ms), that the scope controls export permissions, or that the URL grants access without normal auth. For a security-sensitive URL-minting tool this is a significant gap.

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

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

One short sentence with the action front-loaded and an immediately useful clarifier in parentheses. Nothing wasted, though it is so terse that it borders on under-specification.

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?

A 5-parameter, nested-object tool with no annotations and no output schema needs more than a single sentence. Nothing explains the security semantics of the generated URL or how the optional scope/expiresIn affect the result, leaving the agent reliant entirely on 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 coverage is 80%, so parameters such as scope, expiresIn, and inputParameters are already documented in the schema. The description adds no parameter-level meaning beyond what the schema provides, 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?

The description states a specific verb+resource: 'Create an embedded URL for a project'. The parenthetical clarifies the artifact type (iframe embedding). No sibling tool produces a presigned/embedded URL, so differentiation is effectively established by the unique resource, though it isn't stated 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 only usage hint is the parenthetical 'for iframe embedding'. There is no guidance on when to call this versus e.g. hex-get-project or hex-export-project, no prerequisites, and no mention of the token's short-lived nature affecting call timing.

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. 'Create' implies a write, but the description says nothing about required permissions, whether the project is owned/shared by default, whether it is empty or templated, or any side effects. Only the bare mutation is implied.

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 short sentence with no filler, and the core action and required input are front-loaded. Nothing could be trimmed without losing 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?

For a mutation tool with no annotations, no output schema, and zero parameter documentation, the description is thin. It omits auth requirements, default state of a created project, and what identifying information is returned, leaving the agent to guess at behavior around a state-changing call.

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 0%, so the description must compensate, and it partially does by naming both parameters and flagging 'description' as optional. However, it adds no format, length, or uniqueness constraints for 'title' and nothing about what a description is used for, so the schema's two fields remain largely unelaborated.

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 ('Create a new project') and names the two fields involved. It is clearly distinguishable from the create-* siblings (cell, collection, group, data connection) by resource, but it does not explicitly contrast itself with any of them. Clear and unambiguous, though not maximally differentiated.

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 (e.g., hex-update-project for modifying, hex-export-project for copying), no prerequisites, and no mention of what happens after creation. The agent must infer usage entirely from the name.

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. It discloses exactly one behavioral trait — that the run is asynchronous — but says nothing about permissions, rate limits, or what handle (e.g. a thread ID) is returned for subsequent polling.

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 clause with the async caveat in parentheses. Zero waste, nothing padded.

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 annotations, so the description should ideally say what the async call returns (a thread ID) and how to follow up. It covers the core action adequately but leaves the post-call workflow to inference.

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% for both parameters, so the baseline is 3. The description restates that a prompt is needed but adds no format, length, or content guidance beyond the schema.

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

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

States a specific verb and resource ('Start a new agent thread') plus the required input ('with a prompt'), and 'Start a new' implicitly distinguishes it from the sibling hex-continue-thread. It does not explicitly name alternatives, but the action 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?

No guidance on when to use this versus hex-continue-thread or hex-list-threads, and no prerequisites or exclusions. The agent must infer the routing 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, the description carries the full behavioral burden. It usefully discloses the key consequence ("tokens will stop working"), but omits whether deactivation is reversible, what permissions are required, and whether the user's data survives. Partial disclosure only.

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, effect stated immediately after the action, zero filler. Appropriately sized for a single-parameter mutation.

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 one-parameter tool with no output schema, the description covers the core action and one consequence, but leaves key questions open: reversibility (no sibling for reactivation exists), required authorization, and userId format. Adequate but with clear gaps.

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 0% for the single required parameter, so the description must compensate and does not. It never clarifies whether userId is a UUID, email, or username, leaving a real risk of an incorrect call.

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?

"Deactivate a user in the workspace" gives a specific verb (deactivate) and resource (user), and the second sentence adds the operational effect. It does not explicitly contrast with a sibling, but no sibling covers user deactivation, so ambiguity is low.

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 versus alternatives, no prerequisites (e.g., admin scopes), and no note on what to do instead if the goal is deletion or suspension. The agent must infer usage entirely from the name.

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 destructive operation. It does not state reversibility, required permissions, error behavior for a missing/invalid cellId, or side effects on ordering or downstream runs. The only behavioral hint is the 'draft version' scoping, which is thin for a delete 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?

A single front-loaded sentence with no filler. The scope constraint appears immediately after the verb, so the agent gets the essential meaning first.

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 destructive, unannotated tool with no output schema and an undocumented identifier parameter, this definition leaves too much unspecified. An agent cannot tell what permissions are needed, what happens on failure, or how to source a valid cellId.

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

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

There is one parameter with 0% schema description coverage, so the schema says only that cellId is a required string. The description implies the target is a cell but adds no format (UUID? slug?), no example, and no indication of where an agent obtains a valid cellId (e.g., hex-list-cells). The gap the schema leaves is unfilled.

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 (delete) and resource (cell), plus a scoping qualifier ('draft version of a project') that separates it from sibling delete tools like hex-delete-guide-draft and hex-delete-group. It does not explicitly name those siblings or say how cells differ from their non-draft counterparts, but the action 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 gives no when-to-use context, no prerequisites (does the caller need draft-edit permission? must the cell belong to the caller?), and no alternative tools. The phrase 'draft version' implies a publishing workflow but never says when deletion is appropriate versus hex-update-cell.

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. For a destructive delete it says nothing about irreversibility, permission requirements, or side effects on members/cells that may reference the group.

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, front-loaded sentence with no wasted words. It is efficient, though its brevity contributes to the under-specification elsewhere.

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?

A destructive operation with no annotations, no output schema, and an undocumented parameter needs far more context than this one-liner provides. Critical details about safety and parameter format are 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 0% for the single required parameter. The description only says 'a group', leaving the agent to guess whether groupId expects an ID, name, or slug, and adds no meaning beyond the bare schema type.

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 ('Delete a group') that an agent can distinguish from the sibling group tools (create/edit/list/get). However, it does not explicitly name or contrast with any alternative, so it stops short of the top tier.

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 versus hex-edit-group or hex-list-groups, and no mention of prerequisites such as group ownership or whether deletion is reversible. The agent must infer the context entirely.

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 destructive mutation. It says nothing about irreversibility, required permissions, whether published versions are affected, or error behavior when the ID doesn't 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?

A single short sentence with the action front-loaded and no filler. Its brevity is appropriate for the tool's simplicity, though that brevity is also the source of its gaps.

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 destructive, single-parameter tool with no annotations and no output schema, the description leaves out consequences of deletion and permission requirements. An agent has enough to issue the call but not enough to judge when it is safe to do so.

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 0% for the single orgGuideFileId parameter, and the description only offers the generic phrase 'by ID'. It does not clarify whether this is a guide ID, file ID, or org guide file identifier, nor any format expectations.

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 (Delete) and resource (guide draft), which distinguishes it from siblings like hex-upsert-guide-draft, hex-list-draft-guides, and hex-publish-guide-drafts. It stops short of 5 because 'by ID' adds no distinguishing detail.

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 delete versus upserting or publishing a draft, and no mention of prerequisites or alternatives among the guide-draft siblings. Usage is only implied by 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?

No annotations are provided, so the description carries the full behavioral burden. It says 'edit' but not whether this is a partial update (omitted fields preserved) or a replace, whether permissions are required, whether sharing changes are reversible, or what the response contains — significant gaps 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?

A single compact sentence that front-loads the verb and resource with zero filler. It is efficient, though arguably too terse given the tool's complexity.

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, 25% schema coverage, and a nested sharing object, this mutation tool needs more than one parenthetical line. Key details about partial-update semantics and the sharing config are absent, leaving the agent under-informed.

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 only 25%. The description lists name, description, and sharing, mirroring three of the four properties, but adds no meaning beyond the schema — it does not explain the required collectionId or the opaque 'Sharing upsert config' nested object, so it fails to compensate for the coverage gap.

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

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

Names a specific verb ('edit') and resource ('collection') plus the editable fields, which is clearly distinct from create-collection, get-collection, and list-collections. However it does not explicitly state what separates it from its siblings, so it falls short of the top band.

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 prerequisites (e.g. needing an existing collectionId), and no reference to alternative tools such as create-collection for new collections. The agent must infer the calling context entirely.

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 behavioral burden, yet 'Edit' is the only disclosure. It does not state required permissions, whether unspecified fields are preserved or cleared (patch vs replace), how credential updates are handled, or what sharing changes imply. The mention of 'credentials' is also vague relative to the schema's connectionDetails.

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 — the verb and resource come first and the field list follows. It is efficient, though it is arguably too terse for a five-parameter mutation tool, so conciseness shades into under-specification.

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

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

For a mutation tool with no annotations, no output schema, nested objects, and low schema coverage, the description is far too thin. It omits the required identifier, says nothing about partial-vs-full update semantics, permissions, or side effects on credentials and sharing.

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 40%, so the description should compensate, but it only loosely lists four field areas and omits dataConnectionId — the one required parameter. It also says 'credentials' where the schema says connectionDetails, adding ambiguity rather than precision, and gives no format or nested-object 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?

States a clear verb+resource (edit a data connection) and enumerates the editable fields, so an agent can distinguish it from hex-create-data-connection or hex-list-data-connections. It does not, however, explicitly differentiate itself from hex-update-data-connection-schema, which is the nearest sibling and also mutates a connection.

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 or when-not-to-use guidance and no named alternatives. The agent must infer that this applies only to existing connections and cannot tell when to prefer this over update-data-connection-schema or create-data-connection.

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, but it says nothing about permissions, whether edits are partial or replace existing state, or what happens to members not mentioned. For a mutation tool with zero annotation coverage this is a significant gap — only the word 'Edit' hints at 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?

A single short sentence with no waste and the resource front-loaded, which is structurally sound. Its brevity edges into under-specification rather than genuine conciseness given the tool's complexity.

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?

A mutation tool with no annotations, no output schema, nested object parameters, and 33% schema coverage needs considerably more context than one sentence. The agent lacks enough information about partial-update behavior and the nested members payload to invoke this 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 only 33%, so the description should compensate, and it does name the two optional fields. However, it never explains that 'members' takes a nested {add:{users},remove:{users}} structure, nor that groupId is required, so the semantic gap over the schema remains large.

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 ('Edit a group') and enumerates the editable fields (name, members), which separates it from siblings like hex-create-group, hex-delete-group, and hex-get-group. It does not explicitly name an alternative, but the 'edit' verb plus field list makes the operation 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?

No guidance on when to use this versus hex-create-group, hex-delete-group, or the other sharing-edit tools, and no prerequisites or permission notes. The agent must infer usage entirely 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?

No annotations are provided, so the description carries the full burden. It conveys that this is a mutation ('add or remove'), but says nothing about required permissions, whether operations are atomic when both add and remove are supplied, partial-failure behavior, or what happens if an ID is missing or already present.

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 short sentence with no filler, and the action is front-loaded. It is efficient, though its brevity is achieved partly by omitting needed detail rather than by tight editing.

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

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

For a mutation tool with no annotations, no output schema, and a partially documented schema, the description is too thin: no permission requirements, no return/confirmation behavior, and no relationship to the parallel sharing tools. It is not adequate for correct invocation in ambiguous cases.

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

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

Schema description coverage is 67% (add/remove documented, projectId bare) and the description adds no parameter detail beyond the schema — its phrasing even reverses the schema's direction ('a project from collections' vs. adding collection IDs to a project). With moderate coverage and a mildly confusing framing, it does not compensate for the undocumented projectId.

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 pair (add/remove) and the affected resource (project sharing via collections), so the agent can tell what operation is being performed. It does not, however, distinguish this tool from the three sibling sharing tools (hex-edit-project-sharing-groups, -users, -workspace), leaving the agent to infer the distinction from the name alone.

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 the groups/users/workspace sharing siblings, nor any stated preconditions (e.g., must the project already exist, must the collection exist). The agent gets a purpose but no routing logic.

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 does not disclose whether removal is destructive or reversible, what permission level is required to edit sharing, or what happens to groups not listed in the call.

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 efficient sentence with the operation and resource front-loaded. It is appropriately short but arguably too sparse given the tool's mutation semantics.

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 tool with no annotations and no output schema, the description leaves key questions unanswered: required permissions, effects of partial payloads, and return behavior. The schema covers the access enum but not projectId.

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 adds nothing beyond the generic phrase 'group sharing access'. The remove vs. upsert split and the access-level enum are only visible in the schema, and projectId has no description anywhere.

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 specific verbs (add, update, remove) and a precise resource (group sharing access for a project), which cleanly separates it from the sibling sharing tools for collections, users, and workspace. However, it never names those siblings or explicitly contrasts scope, so the differentiation relies on the tool name.

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 choose this tool over hex-edit-project-sharing-users, hex-edit-project-sharing-collections, or hex-edit-project-sharing-workspace, and no prerequisites or ordering advice. The agent must infer usage entirely from the name.

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 full disclosure burden, yet it says nothing about permission requirements, whether removal is reversible, how partial failures are handled, or whether 'upsert' overwrites existing access levels. For a mutation tool with zero annotation coverage this is a notable gap.

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

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

A single efficient sentence with the operations front-loaded and no filler. It is perhaps too terse for a three-parameter mutation tool, but nothing is wasted.

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 a write tool with no annotations, no output schema, and 67% parameter coverage, the description omits permissions, idempotency/semantics of upsert, and behavior when remove and upsert target the same user. An agent lacks enough context 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?

At 67% schema coverage, the schema mostly documents itself, and the description's 'add, update, or remove' wording loosely maps to upsert/remove. It adds nothing about the access enum values, the email identifier shape, or the role of projectId, so it doesn't meaningfully exceed the schema.

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

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

The description names a specific resource (user sharing access for a project) and enumerates the three operations (add, update, remove). It clearly separates this tool from siblings like hex-edit-project-sharing-groups, hex-edit-project-sharing-collections, and hex-edit-project-sharing-workspace.

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 over the groups/collections/workspace sharing variants, no prerequisites (e.g., required admin permissions), and no note about whether upsert and remove can be combined in one call. Usage is only inferable from the verb list.

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

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

No annotations are provided, so the description carries the full behavioral burden, yet it only says 'update'. It does not disclose that this is a mutation that can revoke access, whether changes are reversible, what permissions are required, or what happens to unspecified settings.

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 tight sentence with no filler and the resource front-loaded. It is efficient, though the brevity reflects under-specification rather than disciplined conciseness.

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 nested-object mutation tool with no annotations and no output schema, the description omits required permissions, the effect of access levels, and the relationship to the sibling sharing tools. An agent cannot confidently invoke it from this text alone.

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

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

Schema coverage is 67% and the description merely echoes the parameter names ('workspace', 'public-web'), adding no meaning beyond the schema. It does not explain the CAN_VIEW/CAN_EXPLORE/NONE levels or the publicWeb enabled flag, and projectId is undocumented in both places.

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 clear verb+resource: updating sharing settings for a project, scoped to workspace and public-web. It partially distinguishes itself from the sibling sharing tools (hex-edit-project-sharing-collections/groups/users), but never names them, so the differentiation is implicit rather than explicit.

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 versus the three sibling sharing tools for collections, groups, and users. There is also no mention of prerequisites (e.g., admin/owner rights) or what selecting 'NONE' does, leaving the agent to infer everything.

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. 'Export' implies a read operation, but it says nothing about permissions required, whether the export is synchronous or queued, size limits, or how the payload is delivered. This is a significant gap for a tool with zero annotation coverage.

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, front-loaded sentence with zero filler. It is efficient, though it errs toward under-specification rather than over-verbosity.

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, no annotations, and an undocumented parameter, the description should explain what the agent receives (file content, URL, or path) and any constraints. It only names the format, leaving the contract incomplete.

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

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

The single parameter projectId has 0% schema description coverage and the description never mentions it or clarifies whether it accepts an ID, slug, or name. The parameter name is self-evident, but the description compensates for none of the missing schema documentation.

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 (export) and resource (project) plus the output format (.hex.yaml), so the agent knows exactly what the tool produces. It does not differentiate from siblings, though none of the listed siblings are export tools, so ambiguity is low.

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, no prerequisites, and no mention of alternatives or related tools. The agent must infer usage entirely from the name.

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 and delivers almost nothing. 'Get' implies a read-only lookup, which is mildly reassuring, but there is no mention of what is returned, auth requirements, error behavior for unknown IDs, or whether the response is a full cell object.

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 with the verb and resource front-loaded and zero filler. It is efficient, though the extreme brevity shades into under-specification rather than disciplined economy.

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 40-plus siblings, a near-identical get-cell-output neighbor, no annotations, and no output schema, this definition is too thin. An agent gets no sense of what a 'cell' contains or what the response shape is, which matters for a fetch tool competing in a dense namespace.

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?

Only one parameter exists and schema coverage is 0%, so the description must compensate. 'By ID' does establish that cellId is a unique identifier used for direct lookup rather than a name or filter, which adds real meaning over the bare string type. It stops short of stating the expected format (e.g., UUID), leaving a gap.

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: retrieve a single cell, addressed by ID. This distinguishes it from the sibling hex-list-cells (plural listing) and implies a singular fetch rather than a bulk operation. It does not, however, explicitly contrast itself with the closely related hex-get-cell-output sibling, which an agent could plausibly confuse it with.

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 hex-list-cells or hex-get-cell-output, nor any stated prerequisites such as needing a valid cell ID or authentication. The only hint is the phrase 'by ID,' which implies you must already have an identifier in hand, but this is left for the agent to infer.

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 behavioral burden. It flags the unstable API status, which is genuinely useful, but says nothing about permissions, whether output may be absent for unrun cells, or rate limits.

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 the unstable-API caveat front-loaded in parentheses. Efficient, though 'Returns the output of a cell' largely restates the 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?

For a tool whose entire value is its return value, there is no output schema and no description of the output format (text, HTML, error objects, etc.), nor handling of cells that have never run. Incomplete for its purpose.

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?

One parameter (cellId) with 0% schema description coverage, and the description does not explain it at all—no format, source, or how to obtain a valid cellId. The description adds nothing beyond the parameter name.

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

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

States a specific verb (Get) and resource (cell output) that clearly differentiates it from hex-get-cell and hex-list-cells. It's clear what it does, though it doesn't compare itself to siblings explicitly.

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

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

No guidance on when to use this versus hex-get-cell or other cell tools. The '(unstable API)' note hints at caution but gives no conditions for selection or prerequisites.

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. It usefully discloses the return media type ('PNG'), but says nothing about permissions, whether it triggers/awaits a render, latency, or error behavior when a chart has not been rendered.

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 zero wasted words, front-loading the verb and return type. Nothing in it is redundant or padded.

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

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

With no annotations and no output schema, the description does cover the essential return type (a PNG image). However, it omits default/expected dimensions, the meaning of cellId, and any linkage to the run-based sibling, leaving invocation details thin for a chart-rendering call.

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%: width and height are documented with ranges in the schema, but cellId (the sole required parameter) is described nowhere. The description adds no parameter meaning beyond what the schema already supplies and does nothing to compensate for the undocumented cellId.

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

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

States a specific verb (get), resource (rendered PNG chart image), and scope (from the draft session). The 'draft session' phrasing implicitly separates it from the sibling hex-get-chart-image-from-run, but it never names that sibling or articulates the distinction outright.

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 'from the draft session' clause implies when this is the right tool versus a run-based variant, but there is no explicit when-to-use/when-not guidance and no named alternative. Usage is inferable 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?

No annotations are provided, so the description carries the full behavioral burden. It does not state permission requirements, what happens if the run is not completed, whether the image is cached/fresh, or any size or rate constraints.

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 tight sentence with the resource and scope front-loaded and no wasted words. Brevity is appropriate, though the compactness leaves gaps elsewhere.

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-parameter tool with no annotations, no output schema, and 20% schema coverage, the description is too thin: it omits dimension semantics, failure modes for incomplete runs, and any return-format hint.

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?

Five parameters with only 20% schema description coverage (staticId alone is annotated). The description does not explain width/height defaults, maximums, or the roles of projectId and runId beyond vague implication, so it fails to compensate for the coverage gap.

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

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

States a specific verb (Get PNG) and resource (chart cell image) scoped to a completed project run, which implicitly separates it from hex-get-chart-image-from-logic. Clear, though it does not explicitly name that sibling or spell out the distinction.

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

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

The phrase 'from a completed project run' implies the run must have finished, but there is no explicit when-to-use guidance, no prerequisites, and no mention of the sibling hex-get-chart-image-from-logic as the alternative for non-run sources.

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. 'Get' implies a read, but it says nothing about permissions, error behavior for unknown IDs, or what 'details' are returned; for a no-annotation tool this is a significant gap.

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

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

A single efficient sentence with the resource and identifier front-loaded. It is appropriately sized for a one-parameter tool, though the brevity contributes to the gaps noted elsewhere.

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 one-parameter read tool with no annotations and no output schema, the description is minimally viable. It does not describe the returned fields or any access requirements, leaving the agent to call it blind.

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 0% and the description only adds 'by ID', which largely restates the parameter name collectionId. It does not clarify format, whether the ID is a UUID or slug, or any constraints.

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

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

States a specific verb (get) and resource (a single collection) with the identifying key (ID). It is clearly distinguishable from hex-list-collections, which retrieves many, though it does not explicitly name that sibling.

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 single-vs-list distinction is implied by 'a single collection by ID', giving an agent enough to infer when to reach for this over hex-list-collections. There is no explicit when-to-use statement, no prerequisites, and no mention of 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?

No annotations are provided, so the description carries the full behavioral burden. It implies a read-only retrieval but says nothing about required permissions, behavior when the UUID does not exist or is inaccessible, or what the returned details include. For a read tool with zero annotation coverage this is thin, though the read-only risk profile keeps it from being worse.

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 or redundancy. It is appropriately sized for the operation, though it stops at the minimum rather than earning full marks with any routing or scope 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 one-parameter read tool with full schema coverage, no annotations, and no output schema, the description is adequate but leaves gaps: it gives no sibling differentiation and no hint about failure modes or returned detail. An agent can call it, but could mis-route to the list or edit siblings.

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

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

Schema description coverage is 100% and the single dataConnectionId parameter already documents itself as 'The data connection UUID'. The description's 'by ID' adds nothing beyond the schema, so the baseline 3 applies.

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

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

States a specific verb (Get), resource (data connection), and scope (single, by ID), which is unambiguous on its own. However, it does not distinguish itself from close siblings like hex-list-data-connections, hex-edit-data-connection, or hex-update-data-connection-schema, which an agent must disambiguate by name alone.

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 versus hex-list-data-connections (to enumerate) or the create/edit/update-schema siblings. The only implicit cue is 'single by ID', which covers the input format but not the selection 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. It does disclose return substance ('including members') and the read-only nature implied by 'Get', but says nothing about access requirements (e.g., group membership), error behavior for unknown IDs, or whether the response is paginated.

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 padding; the resource, scope, and notable payload ('members') all appear 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 one-parameter read tool with no output schema and no annotations, the description covers the essentials: what to pass in and roughly what comes back. It would be a 5 with a note on access prerequisites or how members are represented.

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% for the single groupId parameter, which the schema documents as 'The group UUID'. The description's 'by ID' matches but adds no format, case, or lookup detail beyond the schema, so the baseline 3 applies.

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

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

The description states a specific verb and resource ('Get details of a single group') and scopes it to one item by ID, which distinguishes it in kind from hex-list-groups. It does not name the sibling explicitly, but the singular scope makes the distinction clear.

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

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

Usage is only implied: 'single group by ID' signals this is the lookup tool rather than the enumerating one. There is no explicit when-to-use, no when-not-to-use, and no pointer to hex-list-groups for discovery.

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 one meaningful trait beyond the name — that the call validates the token — which tells the agent this is also an auth probe. It says nothing about error or failure behavior when the token is invalid, which is the key unknown for this 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?

One short front-loaded sentence with zero filler; the identity of the returned entity and the side-effect (token validation) are both 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 zero-parameter read-only lookup with no output schema, the description covers what the tool does and one behavioral nuance. The only gap is the failure mode when the token is invalid, which is minor 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?

The tool takes zero parameters, so the baseline of 4 applies. There is no parameter syntax the description needs to supply.

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: 'get the currently authenticated Hex user'. The word 'currently authenticated' distinguishes it from hex-list-users, which enumerates other users, so an agent can reasonably route between them without reading schemas. It stops short of naming the sibling 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?

Usage is implied by the parenthetical '(validates token)' — the tool doubles as an auth/identity check. However there is no explicit when-to-use statement, no when-not, and no mention of what to do on failure, leaving the agent to infer the 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 behavioral burden. 'Get detailed metadata' implies a read, but nothing is said about required permissions, what 'detailed metadata' actually contains, whether includeSharing has access implications, or any rate limits.

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. It is efficient, though arguably too terse for a tool with an undocumented return shape.

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 read tool this is minimally viable, but with no annotations and no output schema the description is the only place the return contents ('detailed metadata') could be clarified, and it stays vague.

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

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

Schema description coverage is 100%, so both parameters are already documented in the schema. The description adds only the 'by ID' framing for projectId and says nothing about the includeSharing flag, 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?

States a specific verb (Get) and resource (Hex project metadata) scoped to a single record by ID, which separates it from hex-list-projects and hex-get-project-runs. It does not, however, explicitly name or contrast with any sibling tool.

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

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

There is no when-to-use or when-not-to-use guidance, no mention of alternatives such as hex-list-projects or hex-update-project, and no prerequisites. The 'by ID' phrasing only weakly implies a single-record lookup.

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 falls short: it does not disclose pagination behavior despite limit/offset, ordering, result caps, or permission requirements. Only the read-only nature of 'List' is implied.

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, front-loaded sentences with no filler; the verb and scope come first. It is arguably too terse rather than bloated.

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-parameter tool with no annotations, no output schema, and 0% schema description coverage, the description is too thin. It should explain pagination, default trigger scope, and return shape to be sufficient.

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 0% with 5 parameters, so the description must compensate. It only mentions status and trigger-type filtering (covering statusFilter and runTriggerFilter) and leaves limit, offset, and the exact projectId semantics undocumented.

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?

It names a clear verb (List) and resource (runs) scoped to a project, which distinguishes it from run-lifecycle siblings like hex-get-run-status and hex-cancel-run. However, 'all API-triggered runs' conflicts with the runTriggerFilter enum that also accepts SCHEDULED, APP_REFRESH, and ALL, so the stated scope is ambiguous or misleading.

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 versus hex-get-run-status or hex-list-threads, and no prerequisites (auth, project access) are stated. The only hint is the filter mention, which is implicit rather than an explicit selection rule.

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 a meaningful access constraint (Enterprise plan gating). It does not confirm this is a safe read-only operation, nor does it mention pagination, result limits, or what happens for non-Enterprise projects.

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 tightly written sentence with the resource up front and the access constraint tucked 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 simple one-parameter read tool with no output schema, the description covers purpose and access gating adequately. A brief note on the return shape (e.g., list of table names) would fully close the gap, but the omission 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?

Schema description coverage is 0%, so the schema documents nothing about projectId. The phrase 'queried by a project' only weakly implies the ID format/source; the description neither compensates for the coverage gap nor adds syntax or sourcing detail. With just one self-evident parameter, a 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 gives a specific verb and resource ('Get the list of warehouse tables queried by a project'), which is far more precise than the terse name suggests, and the parenthetical scoping note adds precision. It stops short of naming which sibling it contrasts with, but no sibling overlaps meaningfully with this resource.

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 states one real precondition, '(Enterprise plan only)', which is genuine usage guidance an agent could not infer elsewhere. However it gives no when-to-use or when-not-to-use framing relative to the other project-scoped tools.

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, yet it discloses nothing beyond the basic read action. It does not say whether this must be polled, what status values are returned, whether terminal states are reflected, or what auth/scope is required. For a status-lookup tool this is a notable gap.

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

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

One clean, front-loaded sentence with no filler. It is appropriately sized, though its brevity comes at the cost of the missing details noted elsewhere.

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?

No output schema, no annotations, and no parameter documentation, so the description should carry more of the load than it does. The agent gets no idea of the response shape (status enum, timestamps) or polling expectations for a run-status lookup.

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 0% for both required parameters, and the description adds no clarification of projectId vs runId, their formats, or where to obtain them. With two undocumented required params, the description fails to compensate for the coverage gap.

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

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

States a specific verb (get) and resource (status of a specific project run), so the agent can tell it is a read of one run's state rather than a list or an execution trigger. It does not differentiate itself from close siblings such as hex-get-project-runs or hex-run-project, but the purpose itself 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?

No when-to-use guidance, no mention of alternatives (e.g., hex-get-project-runs for enumerating runs, hex-cancel-run for stopping one), and no stated prerequisites such as needing a run to be in progress. Usage must be entirely inferred from the name.

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 implies a read of a specific entity but says nothing about authorization needs, behavior when suggestionId is unknown, or whether the payload is stable/cached.

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 tight sentence with the noun and payload front-loaded; no filler. It is efficient, though arguably too terse given the missing usage and parameter info.

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 one-parameter read with no output schema, the description at least hints at the return content, but with no annotations and no error/failure behavior stated, it is only minimally adequate.

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 0% and the description says nothing about suggestionId — no format, source, or where to obtain the value. The phrase about evidence sources and proposed changes describes the return payload, not the input.

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?

Specific verb ('Get') plus resource ('a suggestion') with a brief indication of payload ('evidence sources and proposed changes'). It is distinguishable from siblings like hex-list-suggestions (plural list) and hex-update-suggestion (mutation), though it never explicitly names 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?

No when-to-use context, no prerequisites, and no mention of the obvious alternatives (list vs. update). The agent must infer usage entirely from the name.

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, and it discloses almost nothing: not what 'status' values mean, whether the thread is scoped to a project, or any permission/rate-limit constraints. Only the implicit read-only nature of 'Get' is conveyed.

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, but the sparseness reads as under-specification rather than deliberate economy for a tool whose schema and annotations are silent.

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 an undocumented required parameter, the description should at minimum explain what 'details and status' returns and what the ID looks like. It leaves all of that to guesswork.

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

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

There is one required parameter (threadId) with 0% schema description coverage, and the description never mentions it or its format (UUID, slug, etc.). 'An agent thread' weakly implies the ID identifies the target but adds no usable 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?

States a clear verb ('Get') and resource ('details and status of an agent thread'), which an agent can distinguish from list_threads, create_thread, and get_thread_messages. It does not explicitly name or contrast those siblings, 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?

No guidance on when to call this versus hex-list-threads, hex-get-thread-messages, hex-continue-thread, or hex-create-thread. The agent must infer usage from the name alone.

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

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

With no annotations, the description carries the full burden, and it does disclose ordering (chronological) and pagination behavior, which are genuine traits beyond the schema. However, it says nothing about permissions, whether the read is safely repeatable, or how pagination state is advanced.

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 tight parenthetical with zero waste and the core verb front-loaded. It may be too terse given the surrounding gaps, but as conciseness it is efficient.

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

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

For a tool with no annotations, no output schema, and 0% schema coverage across three parameters, the description is under-specified: it does not explain the pagination cursor mechanism, what a message object contains, or how to know when the thread ends.

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 0%, so all three parameters (after, limit, threadId) are undocumented anywhere. The parenthetical 'paginated' vaguely gestures at 'after' and 'limit' but provides no format, cursor semantics, or default limit, so the description fails to compensate for the coverage gap.

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 ('List messages in a thread') and adds scope qualifiers (chronological, paginated). An agent can distinguish it from hex-list-threads and hex-get-thread, though it doesn't explicitly name those siblings.

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

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

No when-to-use guidance or prerequisites. Nothing tells the agent when to prefer this over hex-get-thread (thread metadata) or hex-continue-thread, leaving the choice to inference from the names 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 behavioral burden, and it discloses almost nothing. It does not say whether ingestion replaces or merges existing project content, whether it is idempotent, what permissions are required, or what happens on partial payloads.

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 clean sentence with no filler, which is structurally fine. But it is under-specified rather than concise — brevity here comes at the cost of meaning, not from efficiency.

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

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

For a mutation tool with no annotations, no output schema, and a nested payload whose schema description is vague, this definition is materially incomplete. An agent cannot determine required preconditions, payload expectations, or side effects before invoking it.

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 only 50%: 'data' is described merely as 'Ingestion payload' and 'semanticProjectId' has no schema description at all. The description adds no field-level meaning or payload shape, so it fails to compensate for the coverage gap even though this is a nested object parameter.

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

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

The description names a verb ('Ingest'), a resource ('semantic project'), and a source ('uploaded data'), so the general action is inferable. However, it never distinguishes this from the closely named sibling 'hex-update-semantic-project', leaving the agent to guess at the boundary between ingesting and updating.

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, what prerequisites exist (e.g. that data must already be uploaded before calling), or which sibling to prefer for related operations. The noun 'uploaded data' hints at a prerequisite but does not instruct.

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. Beyond 'draft version', it discloses nothing about ordering, pagination, result caps, or auth requirements. For an unannotated list endpoint this is a significant gap.

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

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

A single front-loaded sentence with no filler, and the scope qualifier ('draft version') is placed where it matters. Brevity here edges toward under-specification rather than waste, so 4 rather than 5.

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

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

With three parameters, no annotations, and no output schema, the definition should at minimum explain pagination via 'after'/'limit'. As written, an agent cannot paginate correctly or predict the result shape.

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

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

Schema description coverage is 33%: only projectId is documented. The 'after' and 'limit' parameters are undocumented in both schema and description, and the description never mentions pagination — exactly the compensation expected when coverage is low.

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 clear verb+resource (list cells) plus the content types and the scope qualifier 'draft version of a project', which meaningfully distinguishes it from hex-get-cell, hex-create-cell, and hex-delete-cell. It does not name those siblings explicitly, 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?

No guidance on when to prefer this over hex-get-cell (single cell) or hex-list-projects, and no note on prerequisites such as needing a valid projectId or draft state. Usage must be inferred from the name alone.

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

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

No annotations are provided, so the description carries the full burden. It says nothing about pagination (the 'after' param implies it but no behavior is disclosed), permissions, rate limits, or read-only nature. Only the minimal 'list' verb implies read.

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, front-loaded, no filler. Appropriately sized but perhaps too terse given the undocumented parameters.

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 list tool with 4 parameters, 0% schema coverage, no annotations, and no output schema, the description is insufficient. It doesn't explain pagination, sorting, return shape, or how many collections to expect.

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

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

Schema description coverage is 0%, so the description must compensate for four undocumented parameters. It says nothing about 'after', 'limit', 'sortBy', or 'sortDirection' semantics, leaving cursors, page size, and sort defaults entirely opaque.

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 (List) and resource (collections) with scope (in the Hex workspace). Distinguishable from siblings like hex-get-collection (single) and hex-create-collection, though it doesn't explicitly contrast with them in text.

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, no mention of pagination behavior, no indication of when to prefer this over hex-get-collection. The description provides no routing help.

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 states the read intent but says nothing about pagination behavior (despite after/limit params), result ordering defaults, or that results may be truncated, which matters for a list 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?

A single front-loaded sentence with no filler. It is efficiently written, though its brevity comes at the cost of the missing guidance noted elsewhere.

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 list tool with no annotations and no output schema, the description is too thin: it omits pagination, sorting semantics, and any indication of the shape or volume of returned connections.

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?

Four parameters exist with 0% schema description coverage and the description mentions none of them. after, limit, sortBy (CREATED_AT only), and sortDirection (ASC/DESC) are left entirely unexplained in both schema and description, so the agent cannot tell how to page or sort results.

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?

Clear verb+resource ('List all data connections') and scope ('configured in the Hex workspace'), so the agent knows this is a read-only enumeration of connections. However, it does not distinguish itself from the near-named sibling hex-get-data-connection (single fetch) or hex-create-data-connection, leaving differentiation to inference.

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 and no mention of alternatives such as hex-get-data-connection for a single record. The agent must infer that this is the bulk counterpart to the get sibling.

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 disclosure burden. It adds one genuine behavioral fact — results are paginated — but says nothing about return shape, ordering, permissions, or whether drafts are user- or workspace-scoped, all of which matter for deciding whether to call it.

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 short sentence with the key information front-loaded. Nothing is wasted, though there is also very little content to 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 list tool with two undocumented parameters, no output schema, and no annotations, the definition leaves the agent without pagination mechanics, result shape, or scope. The pagination hint is the only substantive addition.

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

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

Both parameters (after, limit) have 0% schema description coverage, so the description must compensate and largely does not. The word "paginated" only weakly hints that a cursor and page size exist; no format, defaults, or bounds are given for either parameter.

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 ("List") and resource ("draft guides"), which is enough to distinguish it from the sibling write operations hex-upsert-guide-draft, hex-delete-guide-draft, and hex-publish-guide-drafts. It stops short of explicitly naming those siblings as alternatives, but the read vs. write split is inferable from the verb.

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 call this versus the other guide operations, nor any prerequisite or scope note (e.g., whether it returns drafts for the calling user or the whole workspace). Usage is only implied by the name.

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 behavioral burden but discloses nothing about pagination, result size, permissions, or return shape. The claim of listing 'all' groups actively sits in tension with an undocumented 'limit' parameter, which is left unexplained.

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 short sentence that front-loads the action and resource with no filler. Its brevity is efficient, though it tips into under-specification rather than tightness.

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 paginated list tool with four undocumented parameters, no annotations, and no output schema, the description leaves every operational detail to guesswork. An agent cannot determine how to page, sort, or bound 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?

Schema description coverage is 0% and four parameters (after, limit, sortBy, sortDirection) are each undocumented in both schema and description. The word 'all' arguably misleads about the presence of a limit/pagination cursor, and nothing compensates for the coverage gap.

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 ('List all groups'), making the operation unambiguous against siblings like hex-create-group and hex-delete-group. However, it offers no differentiation from adjacent list tools (hex-list-users, hex-list-projects) beyond the resource noun implied by the name.

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 indication of when to use this versus hex-get-group or other list siblings, and no prerequisites or context are given. The agent must infer usage entirely from the name.

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, and it delivers very little beyond the filter list. It does not disclose default return fields, whether results are paginated, whether trashed/archived/unlisted items are excluded by default, or permission requirements for 'viewable'. For a 13-parameter list tool with zero annotation coverage 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?

Two tight sentences with the core purpose front-loaded and no filler. It is efficient, though the brevity edges into under-specification for a tool of this parameter count.

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 13 parameters, no annotations, no output schema, and only 38% schema coverage, the description is too thin. It omits pagination behavior, sorting, and the effect of the includeSharing/includeTrashed/includeArchived/includeUnlisted toggles, which an agent needs to call the tool correctly.

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

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

Schema description coverage is only 38%, so the description must compensate. The filter list maps meaningfully onto statuses, categories, creatorEmail, ownerEmail, and collectionId, but the four include* flags, sortBy, sortDirection, after, and limit receive no explanation in either the description or their schema entries.

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 ('List all viewable projects') and the 'viewable' qualifier hints at access-scoping, so the agent knows this is a read of a filtered project set. It does not distinguish itself from siblings like hex-get-project or hex-list-collections, leaving some ambiguity about which project-listing surface to use.

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 tells the agent which dimensions can be filtered (status, category, creator, owner, collection), which implies when the tool is useful. However, it gives no explicit when-to-use versus alternatives and no exclusions, so usage is only implied 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?

No annotations are provided, so the description carries the full behavioral burden. It discloses pagination and status filtering, but says nothing about ordering defaults, result volume, permissions, or what a returned suggestion contains (no output schema either).

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, which is efficient. However, the terseness is achieved partly by omitting the parameter detail this tool needs, so compactness shades into under-specification.

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-parameter tool with zero schema descriptions, no annotations, and no output schema, the description covers only pagination and status filtering. Three sort/pagination parameters and the return shape are left for the agent to guess.

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 0% across 5 parameters, and the description only alludes to two of them (pagination via 'paginated', status via 'filterable by status'). The enum values for status, sortBy, and sortDirection and the meaning of 'after' are left entirely undocumented.

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 ('List context suggestions') and adds scope qualifiers (paginated, filterable by status). It does not distinguish itself from siblings such as hex-get-suggestion or hex-update-suggestion, but the read-only listing intent 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?

No indication of when to use this versus hex-get-suggestion (single-record fetch) or the update/review siblings. The parenthetical hints at supported operations but offers no selection guidance or prerequisites.

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. It does not mention pagination behavior despite 'after' and 'limit' params, nor the default result size, ordering, or scope defaults, leaving the read semantics largely undisclosed.

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

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

Two short, front-loaded sentences with no filler. The purpose comes first and the filters follow, though it is terse to the point of under-specification rather than wasteful.

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 list tool with no annotations, no output schema, and 0% schema coverage, the description is too thin. It should at minimum explain the pagination params and enum values, none of which appear anywhere.

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 0% across 5 params. The description names three filter dimensions (source, user, type) but adds no semantics: enum meanings, the 'after' cursor, 'limit' bounds, and 'userId' format are all left unexplained.

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: 'List agent threads in the workspace,' and names the filterable dimensions. However, it does not distinguish this from siblings like hex-get-thread or hex-list-thread variants, so a reader must infer the boundary.

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 listing versus hex-get-thread (single thread) or other list tools. Usage is only implied by the verb 'List'; no exclusions or alternatives are named.

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. It discloses the sort order (by name), which is genuine behavioral information, but says nothing about pagination, result size limits, permissions, or return shape. Listing tools are conventionally read-only, which softens the gap.

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

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

A single front-loaded sentence with no waste; the scope, resource, and ordering are all established in one clause.

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 list tool with no output schema, the description covers the essentials but omits pagination behavior and any hint of the returned item shape, which an agent would want when deciding whether to follow up with hex-get-thread.

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?

Zero parameters, so per the rubric the baseline is 4. There is no parameter surface for the description to explain or omit.

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 ('List') and resource ('thread topics in the workspace') plus the sort order. It implicitly distinguishes itself from hex-list-threads and hex-get-thread, though the description never names those siblings, so an agent must infer the topic-vs-thread distinction.

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

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

No guidance on when to use this versus hex-list-threads, hex-get-thread, or the other list_* siblings. The agent gets no prerequisites, no filtering context, and no alternative routing.

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

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

No annotations are provided, so the description carries the full burden. It adds useful pagination behavior (limit, after) beyond the schema, but omits that this is a read-only operation, any permission/auth requirements, and how to traverse all pages. The 'list' verb implies read-only but is never stated.

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, front-loaded with the primary purpose before the pagination note. No wasted words, though the second sentence is thin.

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 list tool with no output schema and no annotations, the description is adequate but incomplete: it ignores the sorting parameters and doesn't describe anything about the returned user set or pagination termination.

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 75%, so the schema documents most parameters. The description reinforces that limit and after are pagination controls, which adds modest value, but it says nothing about sortBy or sortDirection despite those being real parameters.

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

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

States a specific verb and resource: 'List all users in the Hex workspace.' An agent can tell this apart from the sibling hex-deactivate-user, but the description doesn't mention the sibling or further scope details, so it's clear without being maximally differentiating.

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

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

Usage is implied by the name and 'List all users' phrasing – the only user-related sibling is a mutation (hex-deactivate-user), so alternatives are obvious by contrast. However, there is no explicit when/when-not statement or prerequisite 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?

No annotations exist, so the description carries the full burden, and it discloses almost nothing behavioral. 'Publish' is a mutation, yet there is no statement about reversibility, whether the operation is idempotent, permission requirements, or side effects on the draft set. The only useful signal is the batch scope implied by 'all'.

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, front-loaded sentence with no filler. It is efficient, but the brevity comes at the cost of the behavioral detail an agent needs for a mutation tool.

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

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

For a parameterless, annotation-free mutation with no output schema, the description should say what happens on publish and what the agent gets back or should do next. None of that is present, leaving a meaningful disclosure gap.

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

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

The tool takes zero parameters, so the schema has nothing to document and there is no parameter ambiguity to resolve. Baseline 4 applies for a no-argument tool.

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

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

States a specific verb and resource (publish drafted guides) and scopes it to all currently drafted guides. It is distinguishable from hex-list-draft-guides and hex-delete-guide-draft, though it never names those siblings 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?

There is no guidance on when to publish versus when to keep drafting, no prerequisites (e.g., review approval), and no mention of related tools like hex-upsert-guide-draft. The agent must infer everything about timing.

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 mentions 'cache control' but omits critical traits: whether the run is async, whether it returns a run ID to poll, permission requirements, and what the cache flags actually affect. For a mutation-triggering tool with zero annotation coverage 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?

Two tight sentences with the core action front-loaded and the optional inputs mentioned second. No filler, though it is arguably too terse for the tool's complexity.

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 a nested inputParams object, the description should explain the run lifecycle (async, run ID, polling via get-run-status) and cache semantics. It leaves all of that unaddressed, so an agent lacks what it needs to invoke and follow up correctly.

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

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

Schema description coverage is 100%, so each parameter is already documented. The description only gestures at 'input parameters and cache control', adding no meaning beyond what the schema provides. 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 (trigger a run) and resource (a published Hex project), which distinguishes it from siblings like hex-get-run-status and hex-cancel-run. It doesn't explicitly name those alternatives, but the action 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?

Usage is implied by the verb and the 'published Hex project' scope, but there is no explicit guidance on when to use this vs. hex-get-run-status, hex-cancel-run, or hex-get-project-runs, nor any prerequisites (e.g., project must be published).

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 adds only the word "background," implicitly signaling an asynchronous run, but does not disclose whether the operation is read-only or destructive, what permissions are required, whether it blocks or returns immediately, or any side effects.

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

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

A single, front-loaded sentence with no filler or redundancy. Every word contributes to the stated 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?

Given that there are no annotations, no output schema, and 0% parameter documentation, the description is too thin. For an action-triggering tool it should at minimum say what the background run does, whether it is safe/non-destructive, and what the caller receives.

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

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

Schema description coverage is 0% for the single required parameter suggestionId, and the description never mentions or explains the parameter. While the name is fairly self-explanatory, the description does not compensate for the absent schema documentation (e.g., ID format, where to obtain 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 states a specific verb ("Trigger") and a clearly identifiable resource ("background review agent run for a suggestion"). It is unambiguous what the tool does, though it does not explicitly differentiate itself from sibling suggestion tools like hex-update-suggestion or hex-get-suggestion.

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 (e.g., hex-get-suggestion, hex-update-suggestion). No prerequisites, context, or exclusions are stated, leaving the agent to infer usage from the name alone.

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

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

No annotations are provided, so the description carries the full burden. It does not disclose required permissions, whether this is a partial update, side effects (e.g., whether changing source re-runs the cell), or reversibility. The 'and/or' phrasing is the only mild signal that fields are optional.

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 tight sentence with the operation front-loaded and no filler. However, the brevity is achieved partly by omitting useful context rather than by efficient phrasing.

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

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

For a mutation tool with no annotations, no output schema, and three parameters, the description is too thin. It omits update semantics, side effects, and any return behavior an agent would need before invoking it.

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%, with the two payload parameters documented in the schema itself. The description adds little beyond the schema, though 'and/or' implies both are optional alongside the required cellId. A baseline 3 is appropriate given the schema does most of the work.

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

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

The description states a clear verb (update) and resource (cell) plus which fields are updated (source, data connection). It does not distinguish this tool from the many sibling read/create cell tools (hex-get-cell, hex-create-cell, hex-delete-cell), 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?

There is no guidance on when to use this over alternatives such as hex-create-cell or hex-edit-collection, and no prerequisites or context for choosing it. It merely restates the operation.

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 behavioral burden. It signals a mutation (adding/removing statuses) but says nothing about required permissions, whether removals are reversible, or what happens to unmentioned statuses, which is a notable gap for a write operation on a nested updates payload.

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 efficient sentence with the action and target front-loaded and no filler. It is terse rather than padded, though the brevity borders on under-specification.

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

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

For a mutation tool with no annotations, no output schema, a nested updates object, and only 50% schema coverage, the description is not complete enough to call it correctly. Key details about the updates payload and side effects are absent.

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 50% and the only schema description is 'Schema status updates', which is vague. The description's reference to statuses/endorsements adds a little meaning, but the nested 'updates' object structure and the plain 'dataConnectionId' parameter remain unexplained in both places.

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 pair (add/remove), the resource (statuses/endorsements), and the affected targets (databases, schemas, tables in a data connection). It is clear enough to distinguish from generic sibling tools like hex-edit-data-connection or hex-create-data-connection, though it never names or contrasts against 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?

No when-to-use guidance, no prerequisites, and no mention of alternatives such as hex-edit-data-connection. The action itself is implied by 'Add/remove', but an agent gets no selection rationale.

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 the operation mutates project state and singles out endorsements as a status type, but says nothing about required permissions, reversibility, how removal is specified, or side effects on the project.

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 tight sentence with no filler, front-loading the add/remove operation. It is efficient, though its brevity is partly under-specification rather than economy.

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

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

For a mutation tool with no annotations, no output schema, and a nested object parameter that is only half documented, the description leaves too much unspecified. An agent cannot reliably construct the status object or predict the outcome of the call.

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 50%: projectId has no description at all, and the 'status' parameter is a nested object whose internal fields (status name, add/remove action, endorsement) are undocumented. The phrase 'including endorsements' hints at content but does not explain how to construct the object or how add differs from remove.

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 gives a concrete verb pair ('Add or remove') and a resource ('a status ... from a project'), so the action is identifiable. However, 'status' is never defined for a tool named hex-update-project, and nothing distinguishes it from siblings like hex-update-semantic-project or the hex-edit-project-sharing-* tools. Purpose is implied rather than pinned down.

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 explanation of when to add versus remove a status. An agent must infer everything from the one-line purpose statement.

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, and it discloses almost nothing: it does not say whether this is idempotent, whether statuses replace or merge with existing ones, what permissions are required, or what the outcome of the mutation is. The verb 'Add/remove' implies mutation but gives no operational detail beyond that.

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

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

A single front-loaded sentence with no filler or redundancy. It is efficient, though its brevity contributes to the gaps in other dimensions.

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

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

For a mutation tool with no annotations, no output schema, and an undocumented nested object parameter, this description is too thin. An agent knows roughly what the tool does but lacks the parameter shape, permission context, and mutation semantics needed to call it correctly.

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

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

With only 50% schema description coverage and a nested 'status' object whose schema description is merely 'Status updates', the description should compensate but does not. It never explains the shape of the status object, the accepted status values, or what semanticProjectId must reference, leaving the primary nested parameter effectively undocumented.

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 gives a specific verb pair (add/remove) and a resource (statuses on datasets and views within a semantic project), which is concrete enough to distinguish it from project CRUD siblings like hex-update-project. However, it never differentiates itself from the closest relative, hex-ingest-semantic-project, so the agent must infer the boundary.

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 prerequisites, and no mention of alternatives such as hex-ingest-semantic-project or hex-update-project. The agent is left to infer the invocation context entirely from the one-line purpose statement.

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, yet it only restates the mutation. It says nothing about permission requirements, whether the change is reversible, whether it is idempotent, or whether it triggers side effects (e.g., a review flow implied by hex-trigger-suggestion-review).

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 short sentence, front-loaded with the action and resource, with no filler. It is appropriately sized, though the trailing 'etc.' is a small imprecision rather than padding.

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

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

For a mutation tool with no annotations, no output schema, and 0% schema description coverage on two required parameters, this description is too thin. An agent cannot determine authorization needs, return behavior, or how the update interacts with the suggestion review workflow.

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 0%, so the description should compensate, but it only repeats a subset of the status enum already fully defined in the schema. suggestionId — the other required parameter — is never explained, and the 'etc.' truncation omits IN_PROGRESS/RESOLVED that the schema lists.

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 (Update) and resource (suggestion status), which is unambiguous about what the tool does. However, it does not distinguish itself from the closely named sibling hex-update-suggestion-change, leaving the agent to infer the boundary between 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?

No guidance on when to use this tool versus alternatives such as hex-update-suggestion-change or hex-trigger-suggestion-review, and no prerequisites or preconditions stated. The agent must guess the workflow context entirely.

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 says 'update' but does not disclose valid status values, required permissions, whether the change is reversible, or what side effects (e.g., re-triggering review) occur. For a mutation tool with zero annotation support, this is a material gap.

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

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

A single efficient sentence with the action front-loaded and no filler. It is appropriately sized, though it is arguably too terse given the undocumented parameters.

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, no enum for status, and 0% parameter coverage, an agent lacks enough information to invoke this mutation correctly. The description should at minimum enumerate valid status values and note the suggestion/change dependency.

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 0% across 3 parameters. The description names 'status' but does not enumerate allowed values or explain the relationship between suggestionId and changeId, leaving all three parameters' semantics undocumented.

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: updating the status of an individual proposed change within a suggestion. It implicitly distinguishes the granularity from the sibling hex-update-suggestion (whole suggestion vs. individual change), but never names that sibling explicitly, so the differentiation is only inferable.

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 over hex-update-suggestion or hex-trigger-suggestion-review, no prerequisites, and no mention of the review workflow context. The agent must infer the use case entirely 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 provided, so the description carries the full behavioral burden. 'Update or create' usefully discloses upsert semantics, but it never states what happens to an existing draft's content, whether changes are destructive, permission requirements, or how drafts relate to publishing.

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; the verb and the identifying key come first. It is efficient, though almost to the point of under-specification.

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 write/upsert tool with no annotations and no output schema, the description omits side effects, overwrite behavior, and error conditions. An agent can infer the payload from the schema but not the consequences of calling it.

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 there is only one parameter, so the schema already documents the {filePath, content} shape. The description references filePath as the key but adds no format, path syntax, or content expectations beyond the schema.

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

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

Names a specific verb pair (update or create) and resource (guide drafts), plus the identifying key filePath. It is distinguishable from siblings like hex-delete-guide-draft and hex-list-draft-guides, though it does not explicitly name them.

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

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

No guidance on when to use this versus the other guide tools (list, delete, publish). The upsert behavior is implied by 'update or create' but the conditions that select each branch are never stated.

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