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

No annotations are provided, and the description fails to disclose behavioral traits such as whether actions are destructive, require authentication, or have side effects on the system. For an admin tool, this lack of transparency 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 sentence, making it concise but lacking structure. It front-loades the core purpose but omits any breakdown of actions, parameters, or usage examples, which would improve usability.

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 (5 parameters, no schema descriptions, no annotations, output schema exists but not described), the description is far too minimal. It does not cover essential aspects like available actions, parameter roles, or return value, leaving the agent underinformed.

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 has 0% description coverage, and the description does not explain any of the five parameters (action, run_id, refresh, path, workspace). The agent gets no additional meaning beyond the parameter names and types.

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 tool is for running diagnostics and metadata actions on the bridge and agy CLI, which distinguishes it from sibling tools focused on other operations like goals, login, and review. However, 'bounded diagnostics' is somewhat vague, preventing 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 explicit guidance on when to use this tool versus alternatives like agy_run_start or agy_review_commit. The description only notes the scope (bridge and agy CLI), leaving the agent to infer usage context without clear exclusion criteria.

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

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

No annotations are provided, so the description carries the full burden of behavioral disclosure. It lists actions that imply mutations (create, start_target) but does not explain side effects, permission requirements, or what happens on success/failure. The warning about 'dangerously_skip_permissions' is a useful clue but is far from comprehensive behavioral transparency.

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

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

The description is short and front-loaded, but it is under-specified for a tool with 12 parameters and 3 actions. The second sentence about dangerously_skip_permissions is a terse constraint that lacks context. It is concise but not appropriately sized for the tool's complexity.

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

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

Given 12 parameters, 0% schema coverage, and no annotations, this description is grossly incomplete. It fails to explain how to select an action, what parameters mean, or what behavior to expect. The existence of an output schema covers return values, but that does not compensate for the missing input semantics and behavioral context.

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 the 12 undocumented parameters. It only mentions one parameter (dangerously_skip_permissions) and only gives a compliance requirement, not meaning. All other parameters (model, prompt, goal_id, sandbox, objective, workspace, target_name, max_parallel, timeout_seconds, additional_directories) are left entirely 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?

The description states a clear resource ('bridge scheduler goals') and enumerates the supported actions ('create, start_target, status'), which distinguishes it from siblings like agy_run_start or agy_review_files. 'Manage' is broad, but the action list narrows the purpose enough for selection.

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 or when-not-to-use guidance, nor does it mention alternatives among the many sibling tools. The only usage hint is the constraint that 'dangerously_skip_permissions must be true when supplied,' but that is a parameter constraint, not guidance on when to invoke this tool.

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 disclose behavior. It only mentions refresh and opening a login session without explaining side effects, prerequisites, or whether it's interactive.

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 concise sentence, but it lacks sufficient detail. While front-loaded, it sacrifices completeness 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?

Given the tool has 4 optional parameters, no schema descriptions, and no annotations, the one-line description is grossly inadequate for an agent to use 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?

Schema description coverage is 0%, and the description does not explain any of the four parameters. The parameter names give hints, but the tool definition adds no explicit meaning.

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 tool refreshes auth state and optionally opens a login session, using specific verbs and resources. It distinguishes from sibling tools which focus on reviews, runs, and admin tasks.

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 is provided on when to use this tool versus alternatives, such as when a login session is needed or how it relates to other auth-related tools.

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

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

With no annotations, the description carries the behavioral burden. It usefully discloses that this is an asynchronous run requiring agy_run_wait and that agy_run_observe should be avoided except for bridge debugging. However, it does not mention side effects, permissions, sandbox behavior, or whether the operation is read-only, leaving important 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?

Three short sentences, front-loaded with the core purpose, followed by efficient workflow guidance. Every sentence earns its place and there is no filler or repetition of schema content.

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

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

Despite having an output schema, the tool has 12 parameters, no annotations, and zero schema descriptions. The description covers the run lifecycle but leaves many critical parameters unexplained, making it incomplete for an agent trying to invoke the tool correctly with all options.

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 undocumented parameters. It only adds meaning for scope_paths ('use narrow scope_paths') and indirectly for issue ('Keep issue focused'). The other ten parameters, including base_ref, sandbox, include_untracked, and dangerously_skip_permissions, receive no explanation 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?

The description opens with a specific verb-resource pair: 'Start a typed review Run' for 'branch and working-tree changes.' This clearly distinguishes it from siblings like agy_review_commit and agy_review_files, which target different review scopes.

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 provides concrete workflow guidance: wait with agy_run_wait, prefer agy_review_result, and avoid frequent agy_run_observe calls. It does not explicitly state when to choose this tool over agy_review_commit or agy_review_files, but the scope distinction is implied.

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

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

With no annotations, the description carries the behavioral burden. It usefully discloses that the tool returns immediately and that the run completes later, implying async behavior and artifacts. However, it does not mention side effects, permission requirements, sandbox behavior, or what persistent state is created.

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

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

Three short sentences with no filler. The first states the core action, the second gives scoping guidance, and the third directs follow-up behavior. Every sentence 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 an 11-parameter async tool with no annotations and zero schema coverage, the description is too thin. It covers the essential starting action and follow-up routing, but an agent cannot confidently infer required commit/workspace semantics, prerequisites, or side effects.

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

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

Schema description coverage is 0%, and the description only references scope_paths and a focused issue. Required parameters like commit and workspace are left semantically unexplained, and model, sandbox, timeout_seconds, output_file, and dangerously_skip_permissions receive no guidance.

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

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

The description names a specific verb and resource: 'Start a typed review Run for one commit and return immediately.' This also distinguishes it from sibling tools like agy_review_branch and agy_review_files by scoping it to a single commit.

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 practical usage guidance: 'Keep issue focused and use narrow scope_paths when possible.' It also explicitly routes post-completion behavior to agy_review_result instead of polling raw artifacts. It does not provide a full comparison against all review siblings, but the single-commit scope implies the boundary.

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 adds 'artifact-gated' and 'typed' as behavior hints, but does not explain what artifact gating means, whether the Run is asynchronous, what permissions are required, or what side effects occur. This leaves too much behavior opaque.

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, which is structurally clean. However, it is too thin for a 10-parameter tool: 'artifact-gated' and 'typed' are jargon that would benefit from explanation, and no parameter-related structure is included. This is under-specification rather than effective 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?

Given 10 parameters, an output schema, and no annotations, a one-sentence description is insufficient for correct invocation. It omits context about required inputs, the Run lifecycle, and the meaning of artifact gating. While the output schema may cover return values, the description still fails to provide enough surrounding context.

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

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

Schema description coverage is 0% across 10 parameters, including required fields such as paths, issue, and workspace. The description never explains these parameters, their defaults, or their relationships; 'local files' only weakly maps to paths. This is a severe gap for a tool with many undocumented parameters.

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

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

The description states a specific action—'Start'—and a resource: 'artifact-gated typed review Run for local files.' It also distinguishes itself from sibling review tools like agy_review_commit and agy_review_branch by targeting local files. However, key terms like 'artifact-gated' and 'typed' are left undefined, preventing a perfect score.

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 'for local files' gives a clear context for when to use this tool. Yet it does not explicitly contrast it with alternative siblings such as agy_run_start, agy_review_commit, or agy_review_branch, nor does it state when not to use it.

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 discloses the core behavior (validate/summarize) and the precondition (completed runs), but leaves 'consume' ambiguous and doesn't state whether calling has side effects or whether results are one-time. This is minimal but not misleading.

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, action-first, no filler; the second sentence adds practical guidance. This is appropriately concise and well-structured.

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

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

For a one-parameter tool with an output schema, the description covers the basic call context and intended use. However, with no annotations, it omits side-effect behavior, alternative tools, and run_id provenance, leaving an agent to infer too much. Adequate but not complete.

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

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

The schema only defines run_id as a required string and description coverage is 0%. The description never explains what run_id refers to or how to obtain it; it only implies a Run is identified. For a single self-descriptive parameter this is a moderate gap, but the lack of compensation for 0% coverage reduces the score.

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 uses concrete verbs ('Validate and summarize') and names the resource ('artifact from a typed review Run'). It also states the intended scope ('commit, branch, or file review Runs'), which helps distinguish it from generic run tools. It doesn't explicitly name sibling agy_run_result, so some ambiguity remains.

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 explicitly positions itself as the 'Preferred way to consume completed ... review Runs', giving a direct usage condition. It does not mention when to avoid it or name alternative tools, 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?

No annotations provided. The description indicates a destructive action (cancel, terminate) but lacks details on permissions, reversibility, side effects, or what happens to the process group.

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

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

A single concise sentence, but it omits necessary details about usage and behavior. More information could be added without losing 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 simple tool with one parameter and no nested objects, the description is incomplete: it lacks explanation of the parameter, expected state of the run (must be active), and the nature of the response despite an output schema existing.

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 (run_id) with 0% schema description coverage. The description does not explain what run_id is, its format, or how to obtain it, relying solely on the parameter name.

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

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

The description clearly states the tool cancels an active Run and terminates its Antigravity process group, using specific verb and resource. It distinguishes from siblings like agy_run_start or agy_run_wait.

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

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

No guidance on when to use cancel versus other run operations (e.g., agy_run_wait, agy_run_observe). No prerequisites or conditions mentioned.

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 disclosing behavior. It mentions 'stale-write guards' but does not explain what they do when triggered (e.g., error handling, idempotency). No mention of side effects or prerequisites like authentication.

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, well-structured sentence that front-loads the main action and key feature. No wasted words.

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?

Despite an output schema existing, the tool has 5 parameters with 0% schema coverage in the description. The description omits details about parameter types, constraints, and the stale-write guard mechanism, making it incomplete for an agent to use correctly without additional knowledge.

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 only mentions the core action and 'stale-write guards' vaguely. Parameters like expected_event_key and expected_transcript_step are not explained, leaving ambiguity about their purpose and format.

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 ('Send input'), the target resource ('a live foreground Run'), and a specific feature ('optional stale-write guards'). It distinguishes from sibling tools like agy_run_cancel or agy_run_observe by focusing on input delivery.

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 'live foreground Run' implies it should be used only when a run is active, but there is no explicit guidance on when to use this tool versus alternatives like agy_run_start or agy_run_result. The description lacks explicit when-to-use and when-not-to-use instructions.

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 bears full burden. It implies read-only through 'inspect' and 'observation', but does not explicitly state non-destructiveness or any side effects. 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?

Three sentences, front-loaded with purpose, then parameter details. No redundancy or fluff. Highly efficient.

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

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

Despite having an output schema, the description lacks coverage for most parameters (9 out of 11). The tool is complex with many configuration options, but only the view parameter is well explained. Incomplete guidance for effective use.

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 description must compensate. It explains 'run_ids' cardinality and all 'view' values, but leaves 9 other parameters (like 'after', 'limit', 'compact') completely unexplained. Only 2 of 11 parameters are addressed.

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 it is for inspecting run state, with specific view options. It distinguishes from sibling tools that perform actions like cancel, start, or wait, by focusing on observation.

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 provides clear guidance on when to use different views: 'full' for multiple run_ids, others for exactly one. However, it does not explicitly compare to sibling tools or state when to choose this over them.

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 burden. It discloses the main behavioral trait: offset_bytes enables bounded chunk reading. However, it does not state whether the operation is idempotent, what happens if the run is incomplete, or any rate limits or size constraints.

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

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

The description is a single, well-structured sentence that is front-loaded with the core purpose. Every word is necessary; there is no redundancy or verbosity.

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

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

Given the presence of an output schema (no need to explain return values), the description adequately covers the two operation modes. However, it lacks lifecycle context (e.g., that it should only be called after a run completes) and does not mention the relationship to other run-related tools.

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

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

Schema description coverage is 0%, so the description should explain parameters. It only mentions offset_bytes's role (bounded chunk) but does not clarify run_id (required identifier) or max_bytes (default chunk size). The description adds limited value beyond the schema structure.

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 tool reads final result metadata and distinguishes two modes: full read or chunked read when offset_bytes is set. The verb 'Read' and resource 'final result metadata' are specific, and it differentiates from sibling tools like agy_run_input or agy_run_observe.

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 provides no explicit guidance on when to use this tool versus alternatives. It does not mention prerequisites (e.g., that the run must be completed), nor does it contrast with similar siblings like agy_run_observe or agy_review_result.

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 behavioral burden and does disclose key non-obvious behavior: foreground vs. persistent sessions, bridge-owned tasks, and that --dangerously-skip-permissions is always forwarded. It does not discuss failure modes or resource side effects, but the important behavioral constraints are present.

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

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

Four compact sentences, each carrying distinct information with no filler. The purpose is front-loaded and the mode details, sibling pointer, and permission constraint are separated logically.

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 9-parameter surface and no annotations, the description covers the main behavioral choices and the key exclusion. It does not connect to the run lifecycle siblings (e.g., agy_run_wait/result) or clarify workspace prerequisites, so a small completeness gap remains.

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%, yet the description explains the three least obvious parameters: mode values, conversation continuation semantics, and the required dangerously_skip_permissions flag. Several other parameters (model, sandbox, timeout_seconds, additional_directories) are left to inference from their names, so the compensation is partial.

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 first sentence names a specific action (start or continue) and resource (one foreground Antigravity Run), and the mode breakdown adds precision. It also names the sibling for artifact-producing tasks, so the agent can distinguish it from agy_start_with_expected_file.

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 explicitly tells the agent when to use the alternative ('reviews and other artifact-producing tasks') and when to be cautious (interactive mode sparingly). It also explains how conversation_id continues an existing conversation, which guides invocation.

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 behavioral burden. It explains condition values and aliases)Skip and positions the operation as a wait, but it does not explicitly disclose blocking semantics, behavior on timeout, or the meaning of 'after'. This leaves important behavioral details implicit.

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

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

The description is compact and front-loaded. The first sentence gives the purpose, and the remaining text packs parameter and condition semantics with no wasted words.

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 description is strong on purpose and condition values, but the 'after' parameter is completely unexplained and the blocking/timeout behavior is only implied. Since an output schema exists, return values do not need description, but the gaps around 'after' and timeout reduce 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?

Schema description coverage is 0%, so the description must compensate. It usefully explains that run_ids is always a list and expands condition aliases, but it says nothing about 'after' or 'timeout_seconds', leaving two parameters underspecified.

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 first sentence states a specific verb ('Wait'), a resource ('sparse Run events'), and contrasts with the common polling pattern. This clearly differentiates the tool from sibling tools like agy_run_observe or agy_run_result.

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: use this instead of repeatedly polling status. It does not explicitly name alternatives or list when-not-to-use scenarios, but the core usage pattern is communicated effectively.

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 only that the run blocks until expected_file is non-empty. It omits blocking/return semantics, what happens on timeout or missing file, side effects of starting a run, and the safety-relevant default of dangerously_skip_permissions=true. For a launch-type tool with zero annotation coverage, this is a significant gap.

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

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

A single, front-loaded sentence with no wasted words. It is genuinely concise, though borderline over-terse given how much behavioral and parameter information it withholds.

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 9 parameters, no annotations, and 0% schema coverage, one sentence is inadequate. It fails to explain blocking semantics, the timeout default, the permission-skipping default, or parameter purposes. The output schema covers return values, but the rest of the calling context is missing.

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

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

Schema description coverage is 0%, so the description must compensate, but it only clarifies expected_file's role (the run waits for it). The other eight parameters — including the safety-critical dangerously_skip_permissions, timeout_seconds, sandbox, and model — are left unexplained by both schema and description.

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

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

Uses a specific verb (Start) and resource (task Run), and states the defining gating condition — the run 'cannot complete until expected_file is non-empty.' This conveys the tool's distinctive behavior relative to generic siblings like agy_run_start, though it never names a 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?

Gives no guidance on when to use this tool versus alternatives. Siblings include agy_run_start (the generic start), agy_run_wait, and agy_run_cancel, but no when/when-not conditions or alternative routing is provided. Usage is only implied by the name and the file-gating condition.

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