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

With no annotations provided, the description does good work by disclosing that the tool neither runs workers nor modifies files, which is the key safety profile for an analysis tool. It also says what is inspected, compensating partly for the lack of output schema, though it does not mention permissions, error behavior, or execution costs.

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 tightly written sentences, front-loaded with the action and followed by the most important behavioral constraint. Every clause earns its place and no sentence 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?

For a complex tool with 7 parameters, a nested task array, 29% schema coverage, and no output schema, the description gives a useful high-level purpose and names the kinds of results returned. However, it omits guidance on constructing the DAG input or key parameters, so an agent still lacks enough context to invoke it confidently in non-trivial cases.

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

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

Schema description coverage is only 29%, and the description provides no parameter-level guidance at all. It does not explain the required tasks and workspace inputs, the nested task fields, or how write_paths/read_paths affect conflict detection, leaving the agent to infer heavily from the schema.

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

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

States a specific verb (Inspect) and resource (DAG/workflow) and enumerates the analysis outputs: parallel stages, critical-path estimate, redundant edges, and file conflicts. It clearly distinguishes itself from execution-oriented siblings like submit_workflow and wait_workflow by scoping to pre-execution inspection.

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 'before execution' gives clear timing context for when to use this tool, and 'Does not run workers or modify files' implicitly steers the agent toward submission/execution siblings for those actions. It does not explicitly name an alternative tool or list exclusion conditions beyond the non-mutation note.

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

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

With no annotations, the description carries the full burden, and it does disclose the meaningful behavioral trait that the entire process tree is terminated, not just the job. It stops short of stating irreversibility, required permissions, or confirmation/error behavior for an operation that is clearly destructive.

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 front-loaded sentence with no filler; the destructive scope detail is included and nothing is wasted.

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

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

For a destructive single-parameter tool with no annotations and no output schema, the description is adequate on intent but thin on consequences: it omits what success returns, how failures (unknown/already-complete job) are handled, and any permission requirements.

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 job_id parameter is undocumented in both schema and description. The description does not say how to obtain a job_id, whether it accepts a name, or what form it takes, so it fails to compensate for the coverage gap.

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

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

Specific verb (Cancel) plus resource (job), with the added scope that it terminates the complete process tree. No sibling is a competing cancel tool, so the agent can distinguish it cleanly from list_jobs/get_job_status/submit_job.

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?

"Queued or running" implies the tool is inapplicable to already-finished jobs, which is mild routing guidance. However, there is no explicit when-to-use vs when-not statement, no note about prerequisites or what happens if the job already completed.

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

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

No annotations are provided, so the description carries the full burden. It does disclose two meaningful traits: execution must be non-interactive, and mutation is gated behind allow_mutating=true (default false). But it says nothing about what happens on failure, how output is returned, or the destructive potential of arbitrary command 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?

Two tight sentences with the core capability front-loaded and the mutation precondition following immediately. Nothing is wasted, though given the complexity of an arbitrary-CLI tool the brevity borders on under-specification.

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

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

For a tool that executes arbitrary CLI commands with 5 parameters, no annotations, and no output schema, the description is too thin. It omits what 'args' should contain, what 'management commands' means, expected output/error shape, and the purpose of account and timeout_sec.

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

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

Schema description coverage is only 20% — only 'workspace' is documented in the schema. The description adds meaning only for allow_mutating, leaving args, account, and timeout_sec undocumented in both the schema and the description. It fails to compensate for the coverage gap.

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

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

States a specific verb and resource: 'Execute any non-interactive Antigravity CLI argv.' The phrase 'for full CLI coverage' signals this is the generic escape hatch, which loosely implies a relationship to the named siblings (submit_job, health_check, etc.), but 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?

It gives one concrete precondition ('Mutating management commands require allow_mutating=true'), which is useful. However, it offers no guidance on when to prefer this generic executor over the many specific sibling tools like submit_job or get_job_status, leaving that routing decision to inference.

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

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

With no annotations, the description carries the full burden. It does disclose the two behavioral modes and that force terminates the process tree, which is meaningful destructive-action context. However, it omits whether closure is reversible, what happens to session state/history, and any 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?

A single front-loaded sentence with no filler. Both modes are presented in one clause each, so nothing needs trimming and nothing important is buried.

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

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

No output schema and no annotations mean the description should carry more weight for a terminating operation. It covers the force/graceful distinction but says nothing about post-close state, errors on an already-closed session, or what the caller receives back.

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 effectively documents the 'force' parameter by describing the graceful-vs-force-kill branch and confirming graceful is the default behavior. 'session_id' is left unexplained, though it is self-evident from the name and the required field.

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 ('close') and resource ('warm session'), plus the alternate mode ('force-kill its process tree'). An agent can distinguish it from open_session, list_sessions, and session_turn. It stops short of explicitly naming which sibling to use instead in ambiguous cases, so a 4 rather than 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?

Usage is only implied: you close a session when you no longer need it, and choose force when graceful shutdown is insufficient. There is no statement of when not to use it, no prerequisites (e.g., session must be active), and no routing to alternatives such as cancel_job for jobs versus close_session for sessions.

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, yet it only asserts 'same account' and 'session affinity'. It omits permission requirements, side effects, whether a new job is created, and any hint about the 'dangerous' permission_mode option the schema exposes.

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

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

A single front-loaded sentence with no padding or repetition. It is efficient, though its brevity reflects under-specification rather than disciplined conciseness.

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

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

For a six-parameter mutation-style tool with 0% schema coverage, no annotations, no output schema, and permission modes including 'dangerous', the description is far too thin to guide 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 0% across six parameters, including two enums and a required prompt/job_id pair, and the description explains none of them. It adds no meaning about model, effort, timeout_sec, or permission_mode beyond what the bare schema keys show.

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

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

It states a verb (continue) and a resource (a completed conversation), and adds the scoping notion of 'same account' plus 'session affinity'. However, it never distinguishes this from close sibling tools like session_turn or submit_job, leaving an agent unsure whether continuation happens on a job or a session.

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 'a completed conversation' implies a precondition (the job must already be finished), but there is no explicit when-to-use, no when-not-to-use, and no mention of alternatives such as session_turn or submit_job.

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 implies a read-only operation and hints at a local/cached source via 'locally measured', but discloses nothing about permissions, freshness, rate limits, or whether results are stale.

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

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

A single front-loaded sentence with no filler. It is efficient, though at the cost of the detail the other dimensions need.

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

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

For a one-param tool with no annotations and no output schema, the description covers the general return content (token totals, recent jobs) but leaves return shape, freshness, and failure behavior unexplained, which matters given the missing output schema.

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

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

One parameter at 0% schema description coverage, so the description must compensate. 'for one account' only weakly clarifies that 'account' is a single account identifier rather than a list or filter; it adds no format or identifier-scheme detail.

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

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

States a specific verb (Return) and resource (token totals and recent jobs for one account), so the agent knows this is a per-account usage read. It is reasonably distinguishable from list_accounts, but it never names its closest sibling refresh_account_usage, which plausibly returns the same data freshly.

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

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

There is no when-to-use guidance, no prerequisite, and no mention of the closely related refresh_account_usage or get_job_status siblings. The agent gets a purpose but no condition that selects this tool over the 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?

With no annotations, the description carries the full burden, and it does disclose two useful traits: the call can block for up to 60 seconds, and max_chars governs token consumption. However, it omits critical behavior for a polling tool — what is returned or raised if the job is still running after the wait, and whether wait_ms=0 returns immediately or errors.

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, both front-loaded and free of filler. The behavioral constraint (long-poll cap) and the cost-control knob are stated before any detail, which is exactly the right ordering.

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

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

There is no output schema, no annotations, and 0% schema coverage on three parameters, yet the description never describes the return payload ('terminal result' could be text, JSON, or status plus output) or the non-terminal/timeout case. For an async result-fetching tool, those gaps leave the agent unable to interpret the response.

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 and does so partially: max_chars is explained ('controls main-agent token usage') and the '60 seconds' bound gives meaning to wait_ms's 60000 maximum. job_id's format is undocumented, and wait_ms is only implied rather than explained directly.

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

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

States a specific verb and resource ('Get a terminal result') and adds a meaningful scope qualifier ('terminal' rather than status). It implicitly separates itself from get_job_status by targeting the result rather than the state, but it never names that sibling, so differentiation is left to inference.

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

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

No guidance on when to call this versus get_job_status, list_jobs, or continue_job. The 60-second long-poll is described as a capability, not as a decision rule for choosing this tool, and 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?

With no annotations, the description carries the full behavioral burden. It usefully discloses that the response is deliberately compact (a lightweight read), but says nothing about auth requirements, rate limits, or how a not-yet-existing/terminal job is handled.

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

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

A single front-loaded sentence with no wasted words. The purpose and the key scoping trait (compact output) are both delivered immediately.

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

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

For a simple one-parameter read tool this is nearly adequate, but with no annotations and no output schema the description could have said more about what 'compact state and progress' actually contains or how failures are surfaced.

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

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

Schema coverage is 0% for the single job_id parameter, so the schema adds no meaning. The description only implies the parameter identifies 'one job' and gives no format, source, or expected value guidance, leaving a real gap it does not compensate for.

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 (get) and resource (job status/progress) and adds scope ('one job'). It implicitly distinguishes itself from the full-response sibling get_job_result by saying it returns a 'compact' 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?

Usage is only implied: the tool is for checking one job's state/progress, which suggests polling. It never states when to prefer it over get_job_result or wait_workflow, nor any precondition such as needing a submitted job_id.

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 burden. It usefully discloses the snapshot is 'compact' and excludes model response bodies, which is real behavioral context, but says nothing about permissions, cost, rate limits, or whether the snapshot is cached/live.

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

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

A single efficient sentence that front-loads the verb and resource and then enumerates the snapshot contents. No wasted words, though the trailing negation clause is a slightly awkward place for the key exclusion 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 standalone read tool with no annotations and no output schema, the description should explain what the snapshot returns and how it differs from wait_workflow/analyze_workflow. It gives content categories but not enough to call it 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?

Only one parameter exists (workflow_id) with 0% schema description coverage, so the sole formal requirement is the ID. The description implies the ID identifies 'the entire workflow' but adds no format, source, or example. Baseline for a single documented parameter, but the description could have clarified workflow_id semantics.

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

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

States a specific verb (Get) and resource (workflow status), and details the snapshot contents: revisions, file blockers, timings. It doesn't explicitly name a sibling, but 'workflow' scope distinguishes it from job-oriented siblings cleanly.

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

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

No when-to-use guidance, no prerequisites, and no pointer to alternatives. An agent cannot tell from the description whether this precedes or replaces wait_workflow, analyze_workflow, or get_job_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?

With no annotations, the description carries the full behavioral burden and only conveys scope. It does not state that the operation is read-only/side-effect free, whether it is expensive or rate-limited, or what a caller learns from the result, which matters for an inspection tool.

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

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

A single front-loaded sentence with no filler, and the verb leads. It is terse to the point of under-specification rather than being over-long, so it earns near-full marks on structure.

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

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

There is no output schema and no annotations, so the description must explain the return value, yet it never says whether the response is a pass/fail health report or a capabilities list. For a zero-parameter diagnostic endpoint this leaves the agent guessing about what it will get back.

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; per the baseline, a 0-parameter tool scores 4. The schema's additionalProperties=false also means there is no input surface left unexplained.

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

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

Concrete verb ('Inspect') plus an enumerated resource list (server, CLI, vault, orchestration capabilities), which is enough to distinguish it from the job/session/account siblings. It is slightly muddled by not clarifying whether the result is a health status or a capability inventory, so it falls short of a 5.

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

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

No when-to-use, prerequisite, or alternative guidance is offered. An agent can infer a diagnostic/capability-discovery role, but nothing in the text states when this should be called instead of, say, cli_execute or list_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?

With no annotations, the description must carry the full behavioral burden. It discloses that credentials are not exposed and that cached quota and live worker state are included, which adds useful context. But it omits other behavioral details like whether it is strictly read-only, side effects, authentication requirements, or pagination.

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-structured sentence that front-loads the core action and layers in constraints and returned data. 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 zero-parameter, no-annotation, no-output-schema tool, the description covers the returned data adequately but leaves out routing information relative to siblings and omits details like pagination or response shape. It is enough to call the tool but not enough to confidently choose it over alternatives.

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 baseline is 4. There is nothing for the description to add regarding parameter semantics.

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 ('accounts') and clarifies the returned data ('cached quota and live worker state') and a safety property ('without exposing credentials'). However, it does not differentiate itself from sibling tools like get_account_usage or refresh_account_usage.

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?

Provides no guidance on when to use this tool versus alternatives such as get_account_usage or refresh_account_usage. The only contextual hint is the credential-safety note, which is not usage guidance.

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

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

No annotations are provided, so the description carries the full behavioral burden. It does not disclose ordering, pagination behavior, what 'recent' means as a retention window, or any read-only guarantee, leaving real gaps for an agent deciding whether output is bounded.

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

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

A single efficient sentence with the resource front-loaded and the optional filters trailing. Nothing is padded, though the brevity reflects under-specification rather than tight editing.

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

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

For a three-parameter list tool with no annotations, no output schema, and zero schema descriptions, the description is too thin. An agent has no guidance on result size, ordering, or pagination, which matters for a listing operation.

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

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

Schema description coverage is 0%, so the description must compensate for all three parameters. It mentions the state and workflow filters but says nothing about 'limit' (default 50, max 500), the meaning of each enum value, or whether workflow_id accepts an ID versus a name.

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

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

States a specific verb and resource ('List recent jobs') with the scope narrowed to recent jobs. It does not differentiate from siblings like get_job_status or get_job_result, which retrieve single jobs, so an agent must infer the list-vs-get distinction.

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

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

'optionally filtered by state or workflow' implies the conditions under which filtering applies, giving some usage context. It never states when to prefer this tool over get_job_status/get_job_result or list_sessions, and gives no 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 are provided, so the description carries the full behavioral burden. It only states the purpose; it does not disclose read-only safety, side effects, authentication needs, or any other operational trait.

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 wasted words. It is appropriately sized for the tool's simple purpose.

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

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

Given no annotations, no output schema, and an undocumented optional parameter, the description is too sparse. It tells the agent what the tool discovers but not how include_raw changes the result or what form the output takes.

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

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

Schema description coverage is 0% for the single parameter include_raw, and the description never mentions it. The meaning and effect of include_raw are left entirely unexplained, so the description fails to compensate for the low schema coverage.

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 ('Discover') and resource ('exact model ids') with the scope ('accepted by the installed Antigravity CLI'). It clearly distinguishes this tool from all listed siblings, none of which relate to model discovery or listing.

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 explicit when-to-use guidance, prerequisites, or alternatives. Although the purpose implies it should be used to find valid model IDs, no comparisons or exclusions are provided.

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

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

No annotations are provided, so the description carries the full behavioral burden. It discloses that only live/warm sessions are returned and that bound accounts are included, which is useful, but says nothing about ordering, result size, pagination, or auth/permission requirements for a listing tool with no output schema.

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

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

A single short sentence that front-loads the verb and scope with zero filler. Every word, including "live warm" and "bound accounts," carries meaning.

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

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

With no input parameters this is a simple listing tool, and the description conveys what is listed and one attribute of each item. However, with no output schema in place, it does not describe the shape of the returned session records or their volume, leaving the agent to infer the response.

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 are no parameter semantics to document and the schema cannot be richer than it is. Baseline 4 applies; the description does not add anything to explain, but nothing is missing either.

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

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

The description gives a specific verb and resource ("List live warm sessions") and scopes it with two qualifiers that narrow the meaning: "live warm" and "their bound accounts." An agent can tell this is a read-only enumerator distinct from open_session/close_session/session_turn, though it never names those siblings to make the contrast explicit.

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

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

There is no statement of when to call this versus open_session, session_turn, or close_session, nor any prerequisite or context. The word "live" implies a current-state query, but that is inferred, not stated.

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

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

No annotations are provided, so the description carries the full disclosure burden. It hints at session warming and verification but says nothing about resource consumption, concurrency limits, whether an opened session must be closed with close_session, or what the permission_mode/'dangerous' option implies. For a stateful session-creation tool this leaves major behavioral gaps.

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

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

One tight sentence with the action and the purpose front-loaded and no filler. It is efficient, though the compression contributes to the under-specification of an unusually parameter-rich 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?

With 13 parameters, no annotations, no output schema, and sparse schema descriptions, the definition is far too thin. An agent cannot tell what a returned session handle looks like, how long the session lives, or how it interacts with close_session and session_turn.

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

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

Schema description coverage is only 23% (roughly workspace, read_paths, write_paths), leaving ten parameters such as agent, model, effort, permission_mode, include_active, and conversation_id documented nowhere. The description adds no parameter meaning at all, so it fails to compensate for the coverage gap.

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

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

The description gives a clear verb and resource ('Open a ... session') and implicitly positions the tool in a lifecycle alongside siblings like session_turn and close_session. It also names the rationale (low-latency multi-turn work). It does not explicitly contrast itself with those siblings, and 'verified warm stream-json session' is jargon that only partly clarifies what is actually created.

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 clause 'for low-latency multi-turn work' implies when to reach for this tool (repeated turns where latency matters) rather than a one-shot cli_execute. However, it never states prerequisites, when-not-to-use, or names any alternative tool such as cli_execute or session_turn, so the selection guidance must be inferred.

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

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

With no annotations the description carries the full burden, and it does add real behavioral context: the operation runs as zero-token /usage jobs (cost disclosure) and can either return immediately or block/wait. However, it omits the return format of a quota refresh, permissions, and what side effects occur on the accounts.

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 tightly packed sentences with zero waste. The core action is front-loaded and the operational caveats follow, so an agent gets the essentials in one pass.

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

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

For a simple two-parameter tool with no annotations or output schema, the description covers the action, cost model, and wait behavior adequately. It leaves unclear what the refresh actually returns or whether it mutates stored state, which an agent would want to know.

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 partially does: 'one or all accounts' explains that the account parameter is optional and omitting it targets all accounts, and 'return immediately or wait' maps to wait_ms semantics. But no units, default, or maximum (60000) are clarified in the 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?

States a specific verb and resource: 'Refresh live quota for one or all accounts.' An agent can immediately tell this refreshes quota data. It does not name or differentiate itself from the closely related sibling get_account_usage, 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?

'For one or all accounts' and 'can return immediately or wait' imply the two usage modes but never state when to use this versus get_account_usage, when full refresh is warranted, or any prerequisites. Usage is implied rather than guided.

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

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

With no annotations, the description carries the full burden, and it does disclose one real behavior: the full result is persisted locally while max_chars bounds what enters MCP context. However, it says nothing about timeout behavior, what happens on an invalid or expired session_id, or error/recovery semantics.

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 action and followed by the one non-obvious behavioral fact. 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?

No output schema and no annotations means the description is the only source of behavior, and it leaves the return content, timeout_sec effect, and failure modes unaddressed. Adequate for the core action but incomplete for a 4-param, non-annotated tool.

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

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

Schema coverage is 0%, so the description must compensate for all four params. It explains max_chars meaningfully (context budgeting vs. local full result), but session_id, prompt, and timeout_sec get no added semantics beyond their names.

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

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

States a specific verb and resource ('send one prompt to a warm session'), which is distinct from open_session/close_session/submit_job siblings. It doesn't explicitly name or route against any alternative tool, 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?

'Warm session' implies a session must already be open (via open_session) before calling this, but that prerequisite is left to inference. No when-not guidance, no mention of what to do with a cold or expired session.

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, and it does disclose the core model: tasks are queued (async, not blocking) and scheduled across distinct accounts under quota awareness. However, it says nothing about failure/isolation semantics, what happens to partially failed batches, concurrency or the 100-task cap, or what identifier the caller gets back for later tracking.

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 scheduling intent leads and each clause adds information. It is slightly dense with jargon ('quota-aware parallel execution'), but nothing is redundant or wasteful.

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

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

This is a complex, mutation-capable batch-scheduling tool with no annotations and no output schema, so the description should explain return/failure behavior and constraints. It omits what the tool returns for tracking, how failures are reported, and the interaction between write_paths locking and parallel scheduling. Too thin for the tool's complexity.

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?

Top-level schema description coverage is only 25% (workspace documented; tasks, timeout_sec, permission_mode not). The description mentions 'across distinct accounts', which loosely ties to the per-task account param and its omit-for-scheduling behavior, but it never explains the tasks array, the required prompt, batch size limits, or permission_mode. It does not compensate for the coverage gap, though the nested item properties are documented by the schema itself.

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

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

The description gives a specific verb (queue/submit) and resource (tasks), plus a scope qualifier: independent tasks, parallel, quota-aware, across accounts. That is far more informative than the bare name 'submit_batch'. It does not, however, explicitly differentiate itself from sibling submit_job, so an agent still has to infer why batch is preferred over a single job.

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 'independent tasks' implicitly states the eligibility condition for this tool, which is real usage guidance. But it never names submit_job, submit_workflow, or submit_workflow as alternatives, nor does it state when a caller should avoid batching (dependent tasks, shared write paths). Guidance is implied rather than explicit.

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

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

No annotations are provided, so the description carries full burden. It does disclose two important traits: the task is asynchronous and the call returns immediately with a job id (non-blocking). However, it says nothing about scheduling/quota behavior, permission implications, failure modes, or how the job's workspace locking interacts with other calls.

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

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

Two short sentences, zero filler, with the core action and the return contract front-loaded. Nothing to trim.

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

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

For a 17-parameter mutation tool with no annotations, no output schema, and only 41% parameter coverage, the description is far too thin. Behaviors like workspace locking via write_paths, permission_mode semantics, and quota-aware account selection are exactly what an agent needs and none of it is addressed.

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?

17 parameters with only 41% schema description coverage, so the description needs to compensate and does not. It never mentions any of the semantically load-bearing params (permission_mode, write_paths locking, effort, account quota-aware scheduling, estimated_duration_sec), leaving nearly half the parameters documented nowhere.

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 ('Queue one asynchronous Antigravity task') plus scope ('in the caller current workspace') and return behavior ('returns immediately with a job id'). The word 'one' implicitly distinguishes it from submit_batch/submit_workflow, though the description 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 or when-not-to-use guidance. Nothing tells the agent to prefer submit_batch for multiple tasks or submit_workflow for orchestrated pipelines, despite those siblings existing. Only the implied async/non-blocking nature hints at 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, the description carries the full behavioral burden. It usefully discloses scheduling semantics (critical-path priority, file-conflict reservations, read/write overlap behavior) and that it returns an analysis plus a workflow URI. But it omits that this spawns workers that write files (potential destructive surface), how permission_mode governs execution, and any auth/quota considerations.

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 core action and scheduling guarantee. No filler, though the return-value sentence is thin relative to its length.

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 orchestration tool with nested task objects, two enums, no output schema, and no annotations, the description is too sparse. It neither explains the permission modes nor the dependency injection/timeout semantics an agent would need to call this safely and correctly.

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

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

Schema description coverage is only 29%, so the description must compensate — but it only clarifies write_paths (via 'disjoint write_paths') and roughly the return value. Parameters like name, tasks structure, effort, permission_mode, and timeout_sec get no meaning from the description, leaving most of a 7-parameter surface 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 (Queue) and resource (DAG/workflow), and distinguishes itself semantically from submit_job and submit_batch by emphasizing DAG scheduling, critical-path priority, and file-conflict reservations. The sibling differentiation is implicit rather than naming alternatives explicitly, so it stops short of a 5.

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

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

Gives real usage context — independent tasks with disjoint write_paths run in parallel — which tells the agent how to structure a call for concurrency. However, it never says when to choose submit_workflow over submit_job, submit_batch, or analyze_workflow, and gives no prerequisites or exclusions.

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

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

With no annotations, the description carries the full burden and does disclose real behavior: default 60s wait, an upper bound of 300s gated on client timeout, the after_revision mechanism for suppressing stale completions, and the important fact that cancellation stops the wait but not the workers. It still omits what a returned completion looks like and whether the call blocks the session.

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, front-loaded sentences with no filler. The timeout sentence is compressed to the point of being slightly cryptic ("only when the client request timeout exceeds wait_ms"), costing a little clarity for brevity.

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 blocking wait tool with no annotations, no output schema, and zero parameter descriptions, the definition is only partially complete. It never says what the wait resolves to on completion versus change, nor how a caller should interpret a timeout expiry.

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

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

Schema description coverage is 0%, so the description must compensate for all four parameters. It explains wait_ms bounds and the purpose of after_revision well, but wake_on's enum values (completion vs change) are never differentiated in prose and workflow_id is 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: an event-driven wait on an entire workflow. It distinguishes from the status-polling siblings (get_workflow_status, get_job_status) implicitly by describing a blocking wait, though it never names 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?

"Reuse after_revision to suppress old completions" and "up to 300s only when the client request timeout exceeds wait_ms" give conditional context for parameter use, but there is no statement of when to choose this over get_workflow_status or cancel_job, and no explicit when-not guidance.

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