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

The description adds useful behavioral context beyond annotations, especially the privacy-relevant point that `show` returns exactly what is sent and the restriction that granting consent is impossible here. It does not contradict the annotations, but it omits the consequences of revoking consent or whether revocation is immediate.

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 short, front-loaded, and every sentence adds value. It moves directly from the operation to the `show` behavior and then the critical grant limitation.

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

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

For a single-parameter consent tool with annotations and no output schema, the description is largely complete: it explains the two actions, the `show` payload, and the grant limitation. The main missing context is what `revoke` changes operationally and whether it affects subsequent Jev checks.

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 with an enum (`show`/`revoke`) and 0% schema description coverage. The description meaningfully explains `show` output and the grant restriction, but it does not add much semantic detail for `revoke` beyond the action 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?

The description gives a specific verb pair and resource: show or revoke consent to send text to TypeSafe for Jev checks. It is clearly distinct from sibling tools such as agiw_status or agiw_nisi_run, though it does not explicitly name or differentiate against agiw_jev_pre/agiw_jev_post.

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 clearly states an important usage boundary: consent cannot be granted through this tool and must be granted by the user via `agiw-mcp consent grant` in a terminal. It also explains that `show` returns exactly what is sent, but it does not explicitly describe when to prefer revoke or what operational impact revoking has.

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 annotations only covering safety flags, the description adds the operationally critical facts: input truncation at 12 KB, an external service (openWorld) at TypeSafe, the consent/key access gate, and 'Never retried automatically.' Those are exactly the traits annotations cannot convey and directly affect a caller's error handling.

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

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

Three compact sentences, each earning its place: destination and payload, analysis scope, then the advisory nature and access constraints. The truncation limit is front-loaded right on the payload noun.

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 exists, yet the description tells the agent what the service will answer (the four fixed questions) and that the answer is advisory. A short note on the shape of the response or the failure mode when consent/key is missing would make it fully self-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?

The single `report` parameter has 0% schema description coverage, so the description must compensate. It usefully discloses the 12 KB truncation limit, but says nothing about expected content, format, or what happens to the truncated remainder, leaving the bulk of semantics to inference.

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 result or report') and a specific destination ('Jev at TypeSafe'), plus the exact analytical questions asked (self-contradiction, unbacked claims, risk, misclassified findings). This clearly separates it from the sibling agiw_jev_pre, though the differentiation is carried mostly by the pre/post naming rather than an explicit contrast.

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?

'Advisory, not a verdict' sets the trust level, and 'Refused unless consent is recorded and a key is available' names the prerequisite gates an agent must satisfy before calling. It lacks an explicit when-not or a pointer to agiw_jev_pre/'agiw_consent', so it is clear context rather than full routing guidance.

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

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

Adds substantial context beyond the annotations: the payload leaves the boundary to a third party at TypeSafe, has a hard 12 KB cap, can be refused for missing consent/key, and is never retried automatically — an important non-obvious trait given idempotentHint=false. It also discloses the return shape (answers plus flagged items) and that results are advisory, not a verdict.

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?

Four tight sentences, each carrying distinct information — payload, destination, questions asked, return shape, advisory status, preconditions, retry policy. The core purpose is front-loaded with no filler.

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

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

For a one-parameter external-call tool with no output schema, the description covers who receives the data, what is asked, what comes back, refusal conditions, and the epistemic weight of the result. Nothing an agent needs to invoke it safely is missing.

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

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

Schema coverage is 0%, so the description must carry the load, and it does: the single 'task' parameter is characterized as a task description with a 12 KB ceiling matching the schema maxLength. It does not describe expected internal structure or formatting conventions for the payload, so it falls just short of full compensation.

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 concrete verb and resource: send a task description to a named external service (Jev at TypeSafe) for pre-analysis against fixed questions. The 'pre' framing plus 'Advisory' makes it distinguishable from agiw_jev_post, though it never names that sibling explicitly to route the agent.

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?

Gives clear preconditions ('Refused unless consent is recorded and a key is available') and sets expectations ('Advisory, not a verdict'), which tells the agent this is not a gate. It does not explicitly say when to choose this over agiw_jev_post or agiw_readiness.

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?

Very strong disclosure beyond the annotations: a private temporary directory that is removed afterwards, no reads or writes of project files, no execution of generated code, and the return contract (proposed contents plus Nisi's report). It also describes ticket lifecycle behavior — admitted before the run, refused on write-scope overlap, released afterwards — which the annotations cannot convey. All of this is consistent with readOnlyHint=true and openWorldHint=false.

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

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

Three sentences, front-loaded with what the tool does, then safety constraints, then test semantics — no wasted clauses. The sentences are long and densely packed, which slightly strains readability, but every clause carries substantive information.

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

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

With no output schema, the description does the necessary work of stating what comes back (proposed contents and Nisi's report) and what does not happen on disk, which is exactly what an agent needs before committing to a run. Gaps remain around failure modes beyond ticket refusal, timeout behavior, and repair_budget/acceptance_criteria semantics for an 8-parameter tool with nested objects.

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%, so the description must carry more weight. It does add meaning for 'files' (current contents the models may change), the ticket flow, and assertions ('contains/not_contains' alongside built-in checks), but it is silent on acceptance_criteria, timeout_seconds, repair_budget (only 'bounded repair' is hinted at, no default of 1 or cap of 3), and new_files. Adequate but incomplete given 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?

The description gives a specific verb and resource — 'Run one Nisi v0.2.0 workflow' — and enumerates the pipeline stages (draft, syntax check, tests, independent review, bounded repair), plus the crucial input distinction that it operates on 'file CONTENTS you pass in' rather than a project path. That is clearly separable from sibling tools like agiw_status, agiw_readiness, and agiw_jev_*.

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 establishes the usage context well: the caller supplies file contents, the run is sandboxed in a temp directory, and the caller is expected to 'review and apply yourself.' It also states the conditional ticket requirement is governed by config. However, it never names an alternative tool or states explicit when-not-to-use-this conditions relative to the agiw_* siblings, so it stops short of full routing guidance.

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

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

Annotations only declare readOnlyHint=true and openWorldHint=false; the description far exceeds them by enumerating the ordered prerequisites checked and specifying the return contract (READY, or the FIRST failure with an exact fix). It also discloses sensitive handling behavior — macOS key presence checked without reading it, Linux secret-tool output discarded by agiw-mcp — which an agent could not infer elsewhere.

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?

Purpose is front-loaded in the first clause and every subsequent clause carries distinct information — the ready/fail contract, the ordered list, and the platform-specific key handling. The prerequisite sequence and the parenthetical platform detail would read better as a list than as one long run-on sentence.

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, the description carries the full burden and does so: it defines the return states, the deterministic ordering of failures, and what each check inspects. An agent can decide whether to call it and interpret the result without additional documentation.

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

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

The tool takes zero parameters, so there is nothing extra for the description to document; baseline applies. The description correctly spends its words on the check sequence and return values instead of restating an empty 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 (check) and resource (online code mode readiness) and immediately scopes it: "Only checks, never starts work." That single exclusion separates it from mutation-oriented siblings such as agiw_nisi_run or agiw_nev_post without needing to open their schemas.

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

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

"The 'initiate online code mode' check" plus "never starts work" makes the pre-flight use case clear and rules out using it as a launcher. However, it never names an alternative tool (agiw_status, agiw_nisi_run) or states explicitly when to skip this call, so the routing is implied rather than spelled out.

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

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

The annotations already establish readOnlyHint=true and openWorldHint=false, yet the description still adds genuinely useful behavioral context: it discloses that the output contains no secrets, that the home directory is redacted to '~', and that the call starts no work. That is real value beyond the structured fields for a diagnostic 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 dense sentence with every clause earning its place — the safety note and redaction note are both operationally relevant. It reads as a fragment rather than a complete sentence, which slightly weakens front-loading of the primary 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?

For a zero-param, read-only diagnostic with no output schema, the description covers roughly what the caller will receive and reassures about side effects. However, it leaves the response shape unspecified and, more importantly, leaves the overlap with agiw_readiness unresolved, which is the main thing an agent needs to resolve before calling.

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 per the baseline there is nothing for the description to disambiguate. The description correctly adds no parameter discussion, which is the right 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?

The description is a noun-phrase list of what the tool surfaces (versions, configuration, prerequisite status) rather than a verb+resource statement of what it does. It is not a tautology of the name, but it also gives no basis for distinguishing it from the sibling agiw_readiness, which plausibly covers the same 'prerequisites are met' 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 when-to-use guidance, no stated preconditions, and no mention of alternatives. An agent facing agiw_status vs agiw_readiness vs agiw_consent gets no routing signal from this text at all.

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