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

Annotations declare destructiveHint=false and readOnlyHint=false, so the agent already knows this is a state-changing but non-destructive operation. The description adds the meaningful distinction between cancelling a queued item and killing a live process, but it does not say what happens on failure, whether cancellation is reversible, or what state the task ends in. Terminating a process sits in mild tension with destructiveHint=false, though this is a hint-scope ambiguity rather than a clear contradiction.

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 well-formed sentence with the two operating modes front-loaded and zero filler. Nothing to trim and nothing 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?

An output schema exists, so return values need not be explained. The description covers both cancel paths but leaves open the practical questions an agent faces: behavior on an already-finished task, required permissions, and effects on subsequent antigravity_result/antigravity_status calls.

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 a single required taskId parameter and 0% schema description coverage, so the description would ideally clarify which id it expects. It names no parameter at all; the schema's uuid format and pattern do the documenting instead, making the description neutral rather than additive.

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 pair (cancel/terminate) and the exact targets (a queued task, its local agy process), which is more informative than the title alone. It does not, however, distinguish itself from nearby siblings like antigravity_discard or antigravity_cleanup, 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?

Phrasing implies the tool applies to a queued task or a running local process, which is a useful contextual hint. There is no explicit when-to-use/when-not guidance and no mention of the alternatives (discard, cleanup) for stopping or removing work.

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

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

Annotations already declare destructiveHint=true, readOnlyHint=false, and closed-world, so the safety profile is covered. The description adds genuinely useful behavioral context beyond that by naming exactly what is destroyed (finished copies past retention) and what is protected (active copies), which is precisely the context that matters for a destructive tool.

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

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

Two short, front-loaded sentences with zero waste. The destructive scope leads and the preservation guarantee follows, which is the right ordering for an agent deciding whether to call it.

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?

An output schema exists, so return values need not be explained, and there are no parameters to document. The description covers scope and safeguards adequately for a zero-argument cleanup; it omits only peripheral details such as whether COPY_RETENTION_HOURS is configurable or what permissions are needed.

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

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

The tool takes zero parameters, so there is nothing for the description to disambiguate and the baseline of 4 applies. No parameter semantics gaps exist.

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

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

States a specific verb (Remove) and resource (finished copies older than COPY_RETENTION_HOURS) plus a scoping rule (active copies preserved). It does not explicitly contrast itself with similar siblings like antigravity_discard or antigravity_cancel, so an agent must infer that this is the bulk/expiry-based cleanup rather than the single-item removal.

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

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

Usage is only implied: the retention rule signals when it applies, but there is no explicit when-to-use/when-not guidance and no named alternative for targeted removal. An agent can infer the intent but is not steered away from misuse.

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

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

Annotations already declare destructiveHint=true and readOnlyHint=false, so the bar is lower, yet the description adds real value: what is destroyed (copy AND baseline, plus resumed tasks sharing that copy), a refusal rule for active copies, and the reassuring fact that the source project is preserved. It stops short of noting irreversibility or permission requirements.

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

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

Three short sentences, each earning its place, with the core action front-loaded and the constraints following. No filler or repetition of the title.

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?

An output schema exists, so return values need not be explained, and annotations cover the safety profile. The description supplies the destructive scope, refusal condition, and preservation guarantee, leaving only minor gaps such as permissions or irreversibility wording.

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 single taskId parameter carries no schema text, so the description is the only source of context. It establishes that the operation targets a task, which implicitly scopes the ID, but adds no detail on the taskId itself (format, whether it must reference a finished task, etc.).

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/discard) and resource (the copy and baseline of a finished task), including the resumed-tasks-sharing-copy case. It is clear what the tool does, but it never differentiates itself from closely related siblings like antigravity_cancel or antigravity_cleanup.

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?

Implies usage ('of a finished task') and states a precondition ('active copies are refused'), which helps the agent understand when it will fail. However, it names no alternatives or when-not conditions relative to cancel/cleanup siblings, so the routing guidance is only implied.

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

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

Annotations already declare readOnly/non-destructive/non-openWorld, so safety is covered. The description adds real behavioral context beyond that: events are 'live', 'normalized', returned 'after a sequence cursor', and include original payloads. It omits pagination/limit behavior and termination semantics, keeping it below a 5.

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 action and scope. The second sentence is return-value detail that borders on redundant given the output schema exists, but it is not wasteful enough to drop below a 4.

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?

Output schema exists so return values need little explanation, and annotations cover safety. However, with a required taskId and a limit parameter at 0% schema coverage, and no guidance on cursor advancement or loop termination, the definition is only minimally 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%, so the description carries the burden. It explains the `after` cursor implicitly, but says nothing about `limit` (max 1000) or the required `taskId`, leaving two of three parameters undocumented 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 a clear verb ('Read') and resource ('events') plus a cursor-based retrieval mode, but 'agy' is undefined jargon and nothing distinguishes it from siblings like antigravity_status or antigravity_result, which an agent could easily confuse with an event stream.

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 'after a sequence cursor' hints at incremental polling, but there is no explicit when-to-use, no when-not-to-use, and no named alternative (e.g., status vs. events). The agent must infer the polling pattern.

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

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

Annotations already declare the safe read-only, non-destructive, closed-world profile, so the bar is lower. The description adds genuinely useful behavior by explaining that a null result means agy falls back to its own default, which is not derivable from the annotations.

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

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

Two short sentences, zero filler, with the core purpose front-loaded and the null-handling caveat immediately after. Every clause earns its place.

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

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

An output schema exists, so return-value structure need not be documented, and the description still covers the one ambiguous case (null). For a zero-parameter read-only getter, nothing needed to invoke it correctly 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?

The tool takes zero parameters, so the baseline is 4. There is no parameter syntax to clarify, and the sentence about null concerns the return value rather than inputs.

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 ('Return the default model selected') and clarifies scope with 'for subsequent bridge tasks'. It is distinguishable from antigravity_set_model and antigravity_list_models by the word 'selected', though it does not 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?

Usage is only implied: an agent can infer this reads the current selection before calling antigravity_set_model, but the description never states when to use it versus antigravity_list_models or antigravity_status. No prerequisites or 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?

Annotations already declare readOnlyHint=true, destructiveHint=false, and openWorldHint=false, so the safety profile is covered. The description adds which facets are checked (version, auth, capabilities), but says nothing about cost, latency, or side effects like cache refresh — adequate but not rich.

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

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

A single tight sentence that front-loads the verb and lists the inspected facets. No filler, though it is terse enough that it could have afforded one clause of usage context.

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

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

With zero parameters and an output schema present, the description need not explain return values, so the coverage of what is inspected is sufficient for an agent to call it correctly. Only usage routing to sibling diagnostics 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?

The tool takes zero parameters, so per the rubric the baseline is 4. There is nothing to disambiguate, and the description adds no contradictory parameter claims.

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 ('Inspect') and enumerates the resource facets: installed agy version, authentication, and supported capabilities. This clearly separates it from sibling tools like antigravity_status or antigravity_usage, 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?

No when-to-use guidance is given. It is only implied by the word 'Inspect' that this is a diagnostic/health probe, and there is no indication of when to prefer it over antigravity_status or the other read-oriented siblings.

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

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

Annotations already declare destructiveHint=true and openWorldHint=true, but the description adds non-obvious behavior: a mandatory human-confirmation flow via form elicitation that precedes the mutation, and a client-capability gate. This is exactly the kind of context annotations cannot convey, and it does not contradict them.

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

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

Three short sentences: operation, prerequisite, and constraint, ordered by importance. No filler and no repetition of schema or annotation 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?

Covers the mutation, its prerequisite, and the confirmation gate, and an output schema exists so return values need no explanation. The only gap is the undefined taskId, minor given its self-evident naming and the 0% schema description coverage.

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 carry parameter meaning. It partially does for expectedSha256 by tying it to the antigravity_preview SHA-256, but taskId is never explained and no format/source detail is added beyond the regex and pattern in 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 operation ('apply the reviewed patch') preceded by a distinct step ('request human confirmation through MCP form elicitation'), which is more precise than the title alone. The mention of antigravity_preview as the source of the SHA distinguishes it from siblings like antigravity_preview, antigravity_verify, and antigravity_discard.

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?

Explicitly states the prerequisite ('Requires the SHA-256 from antigravity_preview') and the disqualifying condition ('Clients without form elicitation cannot integrate'), and rules out workarounds ('no tool argument substitutes for user confirmation'). The agent knows both when to call it and when it will fail.

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

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

Annotations already declare readOnlyHint=true, destructiveHint=false and openWorldHint=false, so the safety profile is covered. The description adds one genuinely useful behavioral fact — the list is dynamic, reflecting what the backing CLI actually returns for this account rather than a static catalog. It does not mention caching, refresh, or empty-result behavior.

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

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

A single front-loaded sentence with no filler; the account qualifier is attached directly to the resource. It is arguably too terse to carry usage routing, but nothing in the text 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?

An output schema exists, so return values need no elaboration, and a 0-parameter read-only list tool has a very small surface to document. The account-specific, runtime-derived nature of the result is stated, which is the main thing an agent could get wrong. Only the sibling relationship is unaddressed.

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 there is nothing for the description to disambiguate and the baseline of 4 applies. The account scoping statement is the only relevant context and it is present.

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 (model IDs) and scopes it to the current account, which distinguishes it from antigravity_set_model and antigravity_get_model. The phrase 'actually returned by agy models' is slightly cryptic (it presumes knowledge of an external CLI command) but the intent — enumerating this account's available models — is recoverable.

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 reference to the obvious sibling antigravity_get_model, which presumably fetches a single model. The agent must infer that this is the discovery step before set_model, with nothing in the text to confirm or exclude that.

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

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

Annotations already declare readOnlyHint=true, destructiveHint=false, and openWorldHint=false, so the safety profile is covered. The description adds useful scope context by specifying that gitignored and locally excluded files are filtered out. However, it says nothing about authentication, rate limits, or how results are ordered/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 tight sentence that front-loads the filtering semantics with no wasted words. It is perhaps too terse, leaving gaps, but the structure itself 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?

Low complexity (one read-only parameter) and an output schema exists, so return values need not be explained. Still, the meaning of 'eligible for a project copy' is never clarified and the sole parameter is undocumented, leaving the definition 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 single required parameter workingDirectory is never mentioned in the description, so the agent gets no explanation of what path to supply (repo root? any directory?). The description implies a repository context but does not compensate for the documentation 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 (List) and resource (files) with meaningful scope qualifiers: tracked, untracked, excluding gitignore/local excludes. This is clearly distinguishable from sibling list tools like list_models, tasks, or sessions, though the description never explicitly contrasts itself with them.

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

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

No when-to-use guidance, no preconditions, and no alternatives named. The title's 'eligible for a project copy' hints at intent, but the description itself never tells the agent when this tool is appropriate versus other antigravity list/status 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?

Annotations already declare this a safe, closed-world, non-destructive read, so the safety profile is covered. The description adds the finished-task precondition and indicates the payload includes 'client-reported test evidence with stale markers', which hints at freshness semantics. It does not describe error behaviour, size limits, or what happens when includePatch is omitted.

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

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

Two tight sentences, front-loaded with the payload contents and ending on the precondition. It is compact, but the enumerated return fields largely restate what the output schema already provides, so much of the sentence does not earn its place.

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

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

An output schema exists, so return values need not be enumerated, leaving the description thin on the things that matter: neither input parameter is explained and no sibling differentiation is offered. For a read tool with two undocumented parameters and many similar siblings, it is under-specified.

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 carries the full burden for taskId and includePatch, yet it explains neither. The mention of 'patch' refers to an output field, not the includePatch input, so it may even muddy which parameter controls patch inclusion.

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 outlines a diff/preview payload (A/M/D files, stats, patch, SHA-256, test evidence), which conveys what the tool returns and, indirectly, what it does. However it frames the tool as a return-value list rather than a verb+resource, and it names no sibling such as antigravity_read_patch or antigravity_read_result, so the agent cannot distinguish it from those on the description 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?

"Requires a finished task" is a genuine state precondition that tells the agent when the call will be valid, which is real usage guidance. There is no routing against alternatives (read_patch, read_result, result) and no statement of when NOT to use it, so usage is only partially covered.

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

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

Annotations already cover the safety profile (readOnlyHint=true, destructiveHint=false), so the description adds value with the 50000-unit read cap, the 'follow nextOffset until hasMore is false' loop, and the requirement to bind each read to the full preview hash. The hash-binding constraint is a meaningful behavioral detail beyond annotations, though failure behavior on mismatch is left implicit.

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 short, front-loaded sentences with no filler; the core read action leads, followed by path selection, hash binding, pagination, and the alternative. Every sentence adds distinct operational value.

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 an output schema present, return values need not be described, and the description covers pagination, size cap, hash binding, and sibling routing. The only notable omission is the meaning of taskId, but otherwise it is complete for a read tool.

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

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

Schema description coverage is 0%, so the description carries the burden and largely succeeds: it explains limit (max 50000 UTF-16 units), path (optional changed path), offset (via nextOffset), and expectedSha256 ('bind every read to the full preview hash'). Only taskId is left unexplained, keeping it short of a full 5.

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 ('Read ... the current patch') and clarifies scope (up to 50000 UTF-16 units, optional path selection). It also distinguishes itself from the sibling antigravity_preview by routing metadata lookups there, so an agent can tell the two apart without opening a schema.

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

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

Gives clear operating context: select a 'changed path' optionally, 'Follow nextOffset until hasMore is false' for pagination, and use 'preview with includePatch false for metadata' as the alternative. It names an alternative tool but stops short of explicit when-not-to-use conditions.

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

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

Annotations already declare a safe read profile (readOnlyHint=true, destructiveHint=false). Beyond that, the description discloses meaningful behavior: a 'ready' flag that is false while active, chunked/bounded retrieval, and a contentSha256 that must be carried across requests and used to reconstruct the JSON by concatenation.

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

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

Three short sentences, zero filler, and the core chunked-read purpose is front-loaded. The two operative hints (ready-false polling, sha retention) follow in priority order.

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?

An output schema exists, so return-shape explanation is not required. The description covers the essential chunked-read workflow, but leaves the sha-mismatch/error behavior and the meaning of a non-ready response underspecified for a stateful paging tool.

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

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

Schema description coverage is 0% across 4 parameters, so the description carries the burden. It conveys chunking (limit/offset) and the role of contentSha256, but omits the 2-50000 bounds, offset semantics, and what happens when expectedContentSha256 mismatches — leaving key semantics 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 ('Read the final CLI result') and clarifies its distinguishing trait: 'serialized as JSON in bounded chunks.' This differentiates it semantically from the full-result sibling antigravity_result, though it never names that 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?

'Returns ready false while active' implies a polling loop and 'keep contentSha256 for subsequent requests' implies repeated paged calls, so usage is inferable. However, there is no explicit statement of when to prefer this over antigravity_result or antigravity_status, and no exclusion 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 already declare readOnlyHint=false and destructiveHint=false, so the agent knows this writes state non-destructively. The description adds valuable context beyond annotations: it clarifies the tool records client-reported results and that the bridge does not execute or independently verify the command. It also warns against including secrets. It does not describe failure modes or what happens on duplicate recordings.

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 sentences, each front-loaded with essential information: action, binding scope, verification stance, security constraint. No filler or redundancy.

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

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

An output schema exists, so return values needn't be explained. The description covers the key behavioral caveats (client-reported, no verification, no secrets) for a write tool with annotations. It is nearly complete, missing only usage alternatives and some parameter meaning (taskId, expectedSha256).

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. It does by naming what gets bound (command, exit code, output) and the security constraint on output. However, it does not explain taskId or expectedSha256 semantics, leaving two of five parameters undocumented in both schema and description.

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 (record) and resource (client-executed test evidence) with the binding scope stated (command, exit code, output tied to the reviewed patch). It is distinguishable from siblings like antigravity_test (which presumably runs tests) by clarifying that the bridge does not execute the command. Sibling differentiation is implicit rather than naming an alternative 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 description implies usage: record a test the client already ran in the isolated copy. However, it does not state when to use this versus antigravity_test or antigravity_verify, nor any preconditions (e.g., patch must be reviewed first). Usage context is implied, not 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?

Annotations already declare readOnlyHint=true, destructiveHint=false and openWorldHint=false, so the safety profile is covered. The description adds the terminal-state precondition, but says nothing about what happens if the task is still running (error, empty, or block), which is important for a result-retrieval 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?

Two short sentences with no waste, and the core purpose is front-loaded ahead of the sibling redirect.

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?

An output schema exists, so return values need not be spelled out. Still missing: the meaning of includeResult and clarification against antigravity_read_result/antigravity_status, which leaves real ambiguity for an agent choosing among result-oriented 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 0% for two parameters. The description never mentions taskId's UUID format requirement or, more importantly, what includeResult toggles, so the description fails to compensate for the undocumented 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 gives a clear verb+resource: return terminal result, usage and error once the task finishes. It distinguishes itself from antigravity_preview by scoping that sibling to the patch. However, it does not differentiate from the nearby sibling antigravity_read_result, leaving an overlap an agent must resolve on its own.

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 the condition that selects this tool ('once the task finishes') and explicitly routes patch retrieval to antigravity_preview. It does not exclude or address antigravity_read_result or antigravity_status, which appear to cover adjacent ground.

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

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

Annotations already declare readOnlyHint=false, destructiveHint=true, and openWorldHint=true. The description adds only that the session continues in an existing isolated copy; it does not explain what 'continue' entails, what may be modified, or any permission or rate-limit context.

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

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

The description is a single short sentence with no wasted words, but it is severely under-specified for a 10-parameter, destructive, open-world tool. Conciseness here reflects omission rather than efficient communication.

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?

An output schema exists and annotations cover the safety profile, so the description need not explain return values. However, for a complex tool with 10 parameters, no schema descriptions, and destructive behavior, the description leaves usage, parameter semantics, and operation details almost entirely unaddressed.

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 10 parameters, and the description mentions none of them. It provides no meaning for prompt, sessionId, workingDirectory, mode, role, model, includePaths, timeoutSeconds, isolateWorktree, or acceptanceCriteria.

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 ('Continue') and resource ('a completed session'), with the scope 'in its existing isolated copy.' It is clear what the tool does, but it does not distinguish itself from siblings like antigravity_run or antigravity_sessions.

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 'Continue a completed session' implies usage when a session is already completed, but it gives no explicit when-to-use guidance, prerequisites, or alternatives to sibling tools such as antigravity_run.

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

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

Annotations already declare readOnlyHint=false, destructiveHint=true, and openWorldHint=true, so the safety profile is covered. The description still adds real value beyond them by disclosing the sandboxing mechanism (copies into a temp dir, runs agy --sandbox), the includePaths narrowing behavior, and the taskId return token. The 'source is unchanged' claim sits in mild tension with destructiveHint=true but is not a direct contradiction, since the destruction happens inside the sandbox/task state rather than the source tree.

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 tight sentences, front-loaded with the mechanism (copy to temp dir and run in sandbox), then the includePaths qualifier, then the return/immutability note. No filler and no repetition of the title.

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?

An output schema exists, so return values need not be explained, but for a 10-parameter tool with 0% schema description coverage the description covers only one parameter and no workflow positioning. An agent can call it with the two required params but has no basis for choosing mode, role, isolateWorktree, timeoutSeconds, or how to build acceptanceCriteria.

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 there are 10 parameters, so the schema provides names and types but no semantics. The description only explains includePaths ('narrows copied files or folders'), leaving mode, role, model, sessionId, timeoutSeconds, isolateWorktree, workingDirectory, and the whole acceptanceCriteria structure undocumented in prose. That is far too thin to compensate for a 0% coverage 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 gives a concrete verb+resource ('Copy non-ignored project files to a temporary directory and run agy --sandbox there') and states the returned handle (taskId). It clearly separates this from read-only siblings like antigravity_preview/antigravity_status, though it never names a specific sibling to disambiguate from antigravity_resume or antigravity_integrate.

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: nothing says this starts a new task versus sitting alongside antigravity_resume, antigravity_cancel, or antigravity_verify. The phrase 'Returns a taskId' hints that this is the entry point, but the agent must infer that. No exclusions or prerequisites 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?

Annotations already declare readOnlyHint=true, destructiveHint=false, and openWorldHint=false, so the safety profile is covered. The description adds useful provenance context (IDs are recovered from locally persisted tasks rather than fetched from a live session API), but says nothing about freshness, ordering, or whether empty results mean no sessions.

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, no filler, with the core behavior front-loaded ahead of the clarifying note about the missing CLI command.

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?

An output schema exists, so return values need not be explained, and the description supplies the important provenance caveat. Coverage is solid for a zero-parameter read tool, with only minor gaps around result ordering and empty-state meaning.

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

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

The tool takes zero parameters, so there is nothing for the description to disambiguate and the baseline of 4 applies. The description correctly implies no inputs are needed.

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 conversation IDs) and the provenance of the data ('recovered from local persisted tasks'), which an agent can distinguish from most siblings. It does not, however, explicitly differentiate from the closest siblings like antigravity_tasks or antigravity_resume.

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

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

Usage is only implied: an agent infers it should call this when it needs available session/conversation IDs. The note that 'agy does not advertise a session-list command' explains why the tool exists but does not state when to prefer this over antigravity_tasks, antigravity_resume, or antigravity_status.

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 declare readOnlyHint=false, destructiveHint=false and openWorldHint=false, covering the safety profile. The description adds real behavioral context beyond that: the write target (bridge default), the env var it overrides (BRIDGE_DEFAULT_MODEL), the null-to-Auto semantic, and the explicit scope limitation that agy global settings are untouched. Authorization needs and error behavior remain unstated.

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 tight sentences, front-loaded with the action and followed by the null case and the scope boundary. No filler, every clause carries 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?

An output schema exists, so return values need no explanation, and the description covers the single parameter plus the side-effect boundary. What is missing is validation/error behavior for an invalid model ID and whether the value is verified against the agy model list at call time.

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 there is one required parameter, so the description carries the burden. It does so reasonably: the value must be an 'exact model ID from agy models' and null persists Auto rather than being an error. The lack of an enum or concrete ID example keeps it from being a 5.

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 (persist) and resource (an exact model ID as the bridge default), which cleanly separates it from the sibling readers antigravity_get_model and antigravity_list_models. It stops short of naming an alternative explicitly, but the read/write split is unambiguous.

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

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

The description implies usage by describing the null-persists-Auto behavior, so an agent can infer that passing a value selects a model and passing null restores the default. However there is no explicit when-to-use guidance, no statement of prerequisites, and no instruction that the ID must first be obtained from 'agy models'.

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

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

Annotations already establish the safety profile (readOnlyHint=true, destructiveHint=false, openWorldHint=false), so the bar is lower. The description adds useful context on what fields come back and the 'when available' caveat signaling optional/absent fields, which is more than the annotations provide.

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 that leads with the verb and enumerates the returned fields. No filler or redundancy, though it is lean enough to leave gaps rather than being fully economical.

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?

An output schema exists, so return values need not be re-explained, and annotations carry the safety profile. The remaining gap is sibling routing: with 22 peers including antigravity_tasks and antigravity_result, the definition does not say when this status call wins.

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 for the undocumented taskId parameter. It implies the input is a task but adds no format or constraint detail; the self-explanatory name plus the uuid format in the schema keep this at a baseline 3.

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

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

States a specific verb ('Return') and resource ('task metadata, status, process ID and isolated copy path'), making the tool's output scope clear. However, it does not differentiate itself from close siblings like antigravity_tasks or antigravity_result, leaving the agent to infer which retrieval 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 gives no when-to-use guidance and names no alternatives, despite a crowded sibling set (antigravity_tasks, antigravity_result, antigravity_events, antigravity_sessions) where routing matters. Nothing tells the agent whether this is for a single task ID versus a listing.

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

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

Annotations already declare readOnlyHint=true, openWorldHint=false, destructiveHint=false, so the safety profile is covered. The description adds genuine context beyond that: the data comes from local bridge state and survives server process restarts, telling the agent results persist across sessions.

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 that front-loads the action (Recover task IDs and metadata) and then the distinguishing scope. 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?

An output schema exists, so return values need not be explained. For a no-param, read-only list tool the description covers purpose and persistence scope adequately; only explicit sibling routing 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?

Zero-parameter tool, so there is nothing for the description to disambiguate; baseline 4 applies. No parameter confusion is possible.

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 (recover task IDs and metadata) and scopes the source (local bridge state, persisting across server processes). Clear enough to distinguish from antigravity_status/antigravity_result, though no sibling is named explicitly.

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

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

The phrase 'tasks from earlier server processes' implies the recovery scenario (after restart/process loss), which is useful implied usage. There is no explicit when-to-use or when-not-to-use versus siblings like antigravity_result or antigravity_status.

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

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

Annotations already flag destructive/openWorld/non-readOnly, and the description adds substantive context beyond them: asynchronous execution, captured exit status and file fingerprints, optional up to three repair retries, and the absence of Docker/host fallback. That said, it doesn't explain what gets mutated or how expectedSha256 gates execution.

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, front-loaded with the core action and followed by capability, constraint, and routing information. No filler, though the last sentence is somewhat list-like.

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?

An output schema exists so return-value explanation isn't required, and the description covers the async workflow and downstream taskId usage. However, for a destructive tool with 0% schema coverage on a mandatory hash parameter, the description leaves meaningful gaps about how taskId and expectedSha256 are obtained and what timeoutSeconds controls.

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 including a nested command object, so the description must compensate and largely does not. It mentions retry behavior (matching the retries max of 3) but says nothing about taskId, expectedSha256, timeoutSeconds, or the command's executable/args shape.

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 an asynchronous continuation that executes a command) plus what it captures, which separates it from siblings like antigravity_run and antigravity_verify. It never explicitly names a sibling to contrast against, 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?

Gives real routing guidance ('Use the returned taskId for events, result, review and integration') and a negative constraint ('No Docker or host execution fallback'), telling the agent when this path is and isn't appropriate. It does not say when to prefer antigravity_run or antigravity_record_test, so no explicit alternative comparison.

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

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

Annotations already declare readOnlyHint=true and destructiveHint=false, so the safety profile is covered. The description adds real behavioral context beyond that: resumed task counters are session deltas rather than cumulative totals, missing counters remain null, and partial/unavailable usage should be surfaced to the user.

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, front-loaded with the core action before the caveats. Each sentence carries information, though the phrasing is somewhat telegraphic in the opening 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?

An output schema exists so return values need not be explained, and the description covers delta semantics, null handling, and scope boundaries. For a read-only, zero-required-param tool this is largely complete, missing only explicit alternative routing.

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 schema provides no parameter meaning. The description partially compensates by naming the three filter dimensions (task, session, requested model), which map to taskId, sessionId and model, but gives no format or exclusivity guidance.

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 (consolidate) and resource (CLI token usage) scoped by task, session and model. It distinguishes itself by clarifying it is not account quota or billing, though it does not name a sibling alternative directly.

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 clarifies the boundary ('does not report account quota or billing') which is useful when-not guidance, but it never states when to prefer this over siblings like antigravity_status or antigravity_result. Usage is implied rather than routed.

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 declare readOnlyHint=false, openWorldHint=false, and destructiveHint=false, so the agent knows this is a non-destructive but state-changing call. The description adds the meaningful caveat that CLI success is not verification and that client review is client-reported, but it doesn't explain what state is mutated, whether prior verification is replaced, or what permissions are needed.

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 clauses with the core action front-loaded and the caveat trailing. No filler, though the sentence rhythm reads as a list of assertions rather than a structured statement of prerequisites and behavior.

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?

An output schema exists, so return values need no explanation, and the annotations cover the safety profile. What remains missing for a required-hash, criteria-based verification call is the meaning of expectedSha256 and taskId, so the definition is adequate but not complete.

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

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

Schema description coverage is 0% across three parameters, so the description carries the full burden. It gestures at the reviews structure ('ground Codex review quotes in file lines', 'criteria defined before the task') but says nothing about taskId or the required expectedSha256 pin, leaving the two required parameters 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 action (check artifacts, ground review quotes in file lines) against a named resource (task acceptance criteria), so an agent understands this tool validates evidence rather than producing it. It stops short of differentiating explicitly from siblings like antigravity_test or antigravity_record_test, leaving some overlap 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?

It gives one prerequisite ('Requires criteria defined before the task') and a negative boundary ('A CLI SUCCESS or unsupported claim is not verification'), which is useful context. However, it never says when to call this versus antigravity_test, antigravity_record_test, or antigravity_read_result, so the routing decision is only implied.

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