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

With no annotations present, the description carries the full behavioral burden, and it does disclose meaningful behavioral traits: synchronous execution, a bounded timeout guard, automatic conversion to a background job if still running, and support for two execution modes (YOLO autonomous execution vs terminal sandboxing. It does not mention return payload shape, error behavior, or permissions, but it offers far more transparency than a typical terse mutation tool description.

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 three compact sentences with no filler. The main action is front-loaded, and the behavioral caveats are packed efficiently into the subsequent clauses.

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

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

Given the tool's complexity and the absence of an output schema, the description covers the key execution modes, timeout guard, and background-job fallback behavior, and the schema fully documents all parameters. What is missing is an explicit mention of how to retrieve results or how the background-job conversion connects to sibling job tools. That gap is real but moderate, and the schema already hints at background-job ID returns.

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

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

Schema coverage is 100%, so the baseline is already 3; the description adds value beyond the schema by framing yolo and read_only as two execution modes ('YOLO autonomous execution' vs 'lightweight terminal sandboxing') and by explaining the timeout behavior as an auto-conversion to a background job. It does not elaborate every parameter, but the high schema coverage makes that unnecessary.

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

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

The description clearly states the core purpose: 'CONTINUE an existing Antigravity conversation by ID', which identifies both the action and the specific resource. It is distinct from starting a new conversation, but it does not explicitly name sibling tools like antigravity_start or antigravity_start to reinforce the contrast. That differentiation is implied rather than stated.

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 clear context for when to use the tool: you have an existing conversation ID and want to continue it. However, it does not provide explicit when-not-to-use guidance or point to siblings like antigravity_job_status/result for background follow-up. The usage case is inferred from 'by ID' rather than directly contrasted with 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 burden. 'Diagnose' implies a read-only operation, but it does not explicitly state non-destructiveness, authentication requirements, side effects, or whether it performs network calls. It also does not mention what happens if the CLI is unhealthy or if storage metrics are unavailable. This is a minimal disclosure for a tool with behavioral risk.

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 no filler, front-loaded with the verb 'Diagnose'. Every part of the sentence adds meaning, listing the four diagnostic dimensions. It is appropriately sized for a parameterless 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?

The tool is simple (0 params), but there is no output schema, so the description should compensate by explaining what the agent will receive. It does not mention return format, whether it returns a success/failure status, metrics, or logs. It also doesn't clarify prerequisite conditions (e.g., CLI must be installed). For a diagnostic tool, the output is critical, so the description is incomplete on that front, though the rest is adequate for a zero-parameter 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?

The tool has zero parameters and the input schema is empty, so there is no parameter semantics to add. The description lists the diagnostic areas, which is all that is needed. Baseline 4 for 0 parameters 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 names a specific verb ('Diagnose') and a clear resource ('Antigravity CLI health, authentication token status, YOLO permission mode, and storage metrics'). It is immediately distinct from the sibling tools, which focus on running commands, jobs, sessions, transcripts, and models. An agent can tell this is the health/diagnostic tool without opening any 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?

Usage is implied: it is the diagnostic tool among siblings. However, it gives no explicit guidance on when to use it versus alternatives (e.g., 'use antigravity_sessions for session info, antigravity_doctor for health'). No exclusions or preferred scenarios are stated, leaving the agent to infer 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?

With no annotations provided, the description carries the full burden of behavioral disclosure. It mentions the action is destructive ('cancel or kill') but does not elaborate on consequences such as irreversibility, what happens to the job's results, or any permission requirements. For a mutation 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?

The description is a single, front-loaded sentence with zero waste. It states the action, the resource, and the parameter in a compact format, which is ideal for quick parsing by an agent.

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 (one parameter, no output schema), and the description covers the core purpose and parameter. However, for a destructive operation, it lacks details on error conditions (e.g., job not found, already completed) and post-cancellation behavior. Given the absence of annotations, a bit more context would improve completeness.

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

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

The schema covers the single parameter with 100% description coverage ('The Job ID to cancel.'). The tool description adds nothing beyond that – it merely says 'by ID', which is already implied. Since the schema does the heavy lifting, a baseline of 3 is appropriate.

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

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

The description clearly states the action (cancel/kill) on a specific resource (ongoing background Antigravity job) and the identifier (by ID). It is distinct from sibling tools like antigravity_job_status (status) and antigravity_job_result (retrieving results), making its purpose 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 the intended use case: cancelling jobs that are still ongoing. It explicitly conditions the action on 'ongoing' jobs, which helps an agent avoid using it on completed jobs. However, it does not explicitly name alternatives or state when not to use it, but the context is clear enough.

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 does disclose that the tool returns status, duration, trajectory, and final answer, and 'Fetch' implies a read-only operation. However, it does not describe behavior when the job is not yet complete, authentication requirements, or side-effect guarantees beyond the implied 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?

The description is a single, front-loaded sentence with no filler. It immediately names the action and result, then briefly lists return contents. Every word earns its place.

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

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

For a tool with one parameter, no output schema, and no annotations, the description covers purpose, precondition, and key returned fields. It does not discuss error cases or whether to poll with a status tool first, but it is essentially complete for a simple result-fetch 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?

The schema already documents job_id at 100% coverage, so the description is not required to add much. It adds no extra detail about the ID's format, where to get it, or lifecycle, but for a single straightforward identifier parameter this is acceptable. Baseline 3 is appropriate.

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

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

The description states a specific action ('Fetch the full execution report and final output') and a specific resource ('background job'), making the purpose clear. The 'once completed' qualifier also hints at the distinction from status-checking siblings, though it never names them or contrasts the two 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?

It gives clear temporal guidance: use this tool after a background job has completed. It doesn't explicitly mention alternatives such as antigravity_job_status for checking progress, nor does it state 'do not call before completion,' but the precondition is inferable and not misleading.

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 reveals that the tool is fast (<20ms), shows elapsed time, process alive status, and latest tool execution actions, which gives a clear picture of its output and non-destructive nature. It does not mention error conditions or side effects, but for a read-only status check, this is adequate.

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 compact and front-loaded. The first sentence states the purpose, and the second adds performance and output details without any redundant phrasing. Every word serves a function, and the structure is easily scannable.

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 tool with one fully documented parameter and no output schema, the description covers the essential information: what it does, how fast it responds, and what it returns. It does not describe error handling or edge cases, but given the low complexity and the presence of sibling tools, the agent has enough context to invoke 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?

The input schema already provides a complete description of job_id, including its origin from antigravity_start or graceful timeout fallback, achieving 100% schema coverage. The tool description adds no additional parameter meaning beyond what the schema states, so the baseline of 3 is appropriate.

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

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

The description clearly states the verb 'check' and the resource 'real-time progress and live step status of a background job', which is distinct from siblings like antigravity_job_result (final result) and antigravity_start (initiation). It leaves no ambiguity about the tool's core function.

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 for monitoring an in-progress job by highlighting 'real-time' and 'live step status', and the performance note 'returns in < 20ms' suggests it is suitable for frequent polling. However, it does not explicitly contrast with alternatives like antigravity_job_result or state when to stop using it, so it stops short of full guidance.

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

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

With no annotations provided, the description carries the burden of behavioral disclosure. It clearly indicates a read-only listing operation, which is useful. However, it does not disclose details such as whether the list is cached, whether it requires authentication, or what the response format looks like. The description is accurate but minimal.

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, clear sentence that front-loads the action ('List') and the resource ('available models'). Every word earns its place, and there is no redundancy or unnecessary 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 simple list tool with no parameters and no output schema, the description is mostly complete. However, it does not mention what the output will look like (e.g., model IDs, names, metadata) or whether any filtering or pagination is available. Given the tool's simplicity, this is a minor gap, but the description could be slightly more informative.

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

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

The tool has zero parameters, so the schema provides no parameter semantics. The description correctly indicates that the tool lists available models, which is sufficient for a no-parameter tool. Baseline 4 is appropriate because there are no parameters to document.

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

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

The description states a specific verb ('List') and resource ('available models supported by this Antigravity installation'), which clearly identifies the tool's function. It doesn't explicitly differentiate from siblings, but the resource is distinct enough that an agent can infer its purpose among the sibling tools.

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

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

The description implies usage context: it is for listing available models, which is a discovery/read operation. However, it does not explicitly state when to use this tool versus alternatives like run_antigravity or antigravity_sessions, nor does it mention any exclusions 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 provided, so the description carries the burden. It discloses performance ('fast, zero model cost') and data source ('local database'), and the verb 'list or search' implies read-only behavior. However, it doesn't explicitly confirm that no modifications occur, nor does it mention potential errors or limitations. Adequate but not thorough.

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

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

Two sentences, front-loaded with the core action and value proposition, followed by the return fields and usage hint. Zero waste, all sentences earn their place.

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

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

For a straightforward list/search tool, the description covers purpose, returns, and usage context. The limit parameter is in the schema, so pagination is handled. No output schema exists, but the listed return fields suffice. Missing only minor details like error handling or sort order, which are not critical for correct invocation.

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 both parameters are well-described in the schema (limit with default, query for filtering titles/summaries). The tool description adds minimal extra meaning beyond restating the search capability. Baseline 3 is appropriate since the schema already handles parameter 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?

Description states a specific verb ('List or search'), resource ('historical Antigravity sessions'), and key differentiators ('local database, fast, zero model cost'). It clearly distinguishes from siblings like run_antigravity or antigravity_start, which execute sessions, by focusing on historical lookup.

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 'Use this to find a conversation ID to resume', which is clear usage guidance. It doesn't enumerate alternatives, but the context makes it obvious that this is for retrieval, not execution. Could be stronger by mentioning when not to use, but the sentence provides actionable direction.

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?

Because there are no annotations, the description carries the behavioral disclosure burden. It does disclose the key behavior clearly: this tool is asynchronous, returns a job ID, and has a continuation path. However, it does not disclose tool-level side effects such as the dangerous default yolo/skip-permissions behavior or what happens to workspace writes, which are meaningful transparency gaps for a no-annotation 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?

The description is two sentences with no filler. The core behavior is front-loaded first, followed by the main use case and the conversation_id edge case. Every sentence earns its place and the structure makes it easy for an agent to quickly select or reject the 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 an asynchronous submission tool with no output schema, the description covers the essential contract: no waiting, a job ID is returned, long-running tasks are appropriate, and existing conversations can be continued via conversation_id. It would be more complete if it pointed to the companion status/result tools or called out the default yolo safety behavior, but what is needed to invoke the tool correctly is mostly present.

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

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

The schema description coverage is 100%, so the baseline is 3 even if the description adds little parameter-level detail. The description only restates the conversation_id continuation concept, which the schema already covers. It does not introduce new meaning about defaults, formats, ranges, or interactions among the seven parameters, so there is no reason to score above baseline.

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

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

The description clearly states the exact action: 'Submit an asynchronous task to Antigravity and return a job ID without waiting for model completion.' This names the verb, resource, and response behavior, and it clearly differentiates itself from the synchronous-looking sibling run_antigravity. The continuation support via conversation_id is also explicitly called out, adding specificity without ambiguity.

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 explicit context with 'Use this for long-running tasks (e.g. multi-minute analyses, large refactors),' which tells an agent when this tool is appropriate. It also clarifies the continuation case via conversation_id. It does not explicitly name siblings like antigravity_continue as alternatives or state when not to use them, so it stops short of a 5.

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 that the operation is a fast local read with zero token cost, and specifies the return content (user prompts, tools executed, command outputs, conclusions). It does not mention auth or edge cases, but for a read-only operation this is adequate.

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

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

Two sentences, front-loaded with purpose, and the second adds relevant behavioral context. No wasted words or repetition of schema details.

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

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

For a tool with three well-documented parameters and no output schema, the description adequately explains what is returned and the nature of the operation. It lacks caveats about missing conversations or pagination beyond max_steps, but these are minor given the simplicity.

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

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

Schema description coverage is 100%, so the baseline is 3. The description mentions 'by ID' for conversation_id and 'recent steps' for max_steps, but these add no substantive meaning beyond the schema's own descriptions. The performance note is not parameter-specific.

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 (Read), resource (execution transcript), and scope (by ID), clearly distinguishing it from siblings like antigravity_sessions (list) and antigravity_job_status (status). The phrase 'detailed execution transcript' leaves no ambiguity about what is retrieved.

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 clearly implies the use case (reading step-by-step history of a session) but does not explicitly name alternatives or exclusion conditions. It is obvious when to use it vs. listing sessions, but no direct comparison is 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?

With no annotations provided, the description carries the behavioral burden and does meaningful work: it discloses synchronous execution, a bounded timeout, automatic conversion to a background job, YOLO autonomous execution, and terminal sandboxing. It does not cover side effects like workspace writes or permission implications, but the key runtime behaviors are disclosed.

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 focused sentences with no filler. The first sentence states the core purpose, and the second covers the most important behavioral distinctions. Every clause earns its place.

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

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

For a 7-parameter tool with no output schema and no annotations, the description covers the essential runtime contract: new task, synchronous wait, timeout guard, and background-job fallback. The schema fills in parameter details, and sibling tools cover follow-up actions, so only minor gaps remain (e.g., exact return 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 100%, so the schema already documents all 7 parameters individually. The description adds high-level context by mentioning YOLO and sandboxing, but it does not add meaning beyond what the parameter descriptions already provide. Baseline 3 is appropriate.

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

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

The description clearly states the action: 'Start a NEW task using Google Antigravity AI Agent (agy).' It also adds distinguishing behavioral details such as synchronous execution and timeout-guard conversion to a background job, which separates it from continuation and job-management siblings. However, it does not explicitly differentiate itself from the closely named sibling antigravity_start.

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 conveys useful context: it is for new tasks, runs synchronously up to a timeout, and automatically converts to background execution. But it does not explicitly say when not to use this tool or name alternatives like antigravity_start for long-running/background workflows, nor does it direct the agent to antigravity_job_status/result after conversion.

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