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

No annotations are provided, so the description carries full burden and does well: it discloses the model family used, the specific behavior (hunts for flaws, edge cases, security issues, unstated assumptions), and the call-rejection rule for empty input. It doesn't cover cost/rate limits beyond the `schema` latency-and-token note, or what happens to files read from disk, keeping it from a 5.

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

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

Three sentences, each earning its place: identity, when-to-use with rationale, and the input/return contract. Front-loaded with the 'what it is' before the usage rule.

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 9-param tool with no annotations and no output schema, the description covers purpose, usage rule, input constraint, and the optional structured-output path. Missing details are minor (return shape when no schema is passed, cost/working-directory behavior), but an agent could call 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 100%, so the schema already documents all 9 parameters in detail (cwd, dirs, files, focus, model, effort, schema, content, slash_commands). The description adds only the `content`-or-`files` mutual-requirement and the `schema` structured-output behavior, which is useful but marginal against the schema's own documentation. Baseline 3 is correct.

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 + resource ('adversarial second opinion from a different model family (Gemini Pro)') and it explicitly distinguishes itself from sibling delegation tools by naming the critique/review use case (plan critiques, design reviews, pre-merge code review). An agent can tell this apart from `delegate` or `delegate_many` without opening schemas.

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

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

States 'ALWAYS use this for plan critiques, design reviews, and pre-merge code review' — an explicit when-to-use directive — and adds the input constraint 'Pass either `content` or `files` — a call with neither is rejected.' Clear routing plus an exclusion/precondition.

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

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

No annotations provided, so description carries full burden. It discloses what the tool returns and hints at read-only nature ('what this bridge has spent', 'what it can still do'), implying a safe status check. However, it doesn't state whether it has side effects, requires auth, or is idempotent. The informational verbs strongly imply read-only but leave room for ambiguity.

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 first sentence is a dense list of returned data that, while informative, is long and somewhat run-on. The second sentence gives usage guidance clearly. The description front-loads the purpose but the enumeration could be tightened; every item earns its place by describing the return payload, but structure could be improved.

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

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

For a zero-param status tool with no annotations and no output schema, the description does a good job listing what is returned, compensating for the lack of output schema. However, it doesn't disclose safety profile (read-only status), potential side effects, or failure modes. Given no annotations, more behavioral disclosure would be expected.

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

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

Zero parameters, so baseline is 4 by rule. Description doesn't need to explain 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 (reports/spends) and resource (bridge status) with a detailed enumeration of what is returned: tokens, quotas, runs, model chain, set_model choice, etc. Distinguishes itself from siblings like set_model and delegate, though it doesn't explicitly name a sibling to compare against.

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 clear when-to-use guidance: 'Check this before a large fan-out, or to list models before set_model.' This gives two concrete triggers and references a sibling for model listing. No explicit exclusions, but the context is well-defined.

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 disclosure burden, and it does the most important part well: it names the context-isolation behavior ('files never enter your context — only the answer does'), which is the key mental model for a delegation tool. It does not state the safety profile (read-only vs. workspace-mutating), latency, or the prompt-injection hazard that is only mentioned inside the slash_commands parameter description, so it stops short of full behavioral disclosure.

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, all load-bearing: purpose/mechanism first, then the trigger conditions, then the context-cost payoff. No filler and the most decision-relevant information is front-loaded.

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 8-parameter tool with full schema coverage and no output schema, the description covers purpose, triggers, and the return-value shape ('only the answer does'), which is enough to call it correctly. It leaves the security-relevant slash_commands caveat stranded in the parameter description and never states whether analysis is strictly read-only, which are minor but real gaps.

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

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

Schema description coverage is 100% across all 8 parameters, so cwd, dirs, model, effort, schema, and slash_commands are already documented in the schema. The description adds only implicit guidance about the files parameter (large files, multi-file scope) and nothing about the rest; baseline 3 is correct when the schema does the heavy lifting.

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 (delegate file analysis) plus the mechanism (Antigravity CLI / Gemini), and explicitly contrasts itself with the default behavior of reading files directly. An agent can tell this apart from generic delegation or web/search siblings without opening any schema.

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

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

Gives explicit, testable triggers — '>200 lines' or '>3 files' — plus concrete task categories (logs, database dumps, generated code, cross-file reviews, comparisons). This is exactly the when-to-use guidance that lets an agent route between this and reading files itself.

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 work is delegated to an external CLI and that this preserves the caller's context, which is genuinely useful, but it says nothing about latency, token cost, or that results come back as text (the schema mentions structuredContent only under 'schema'). Key trade-offs are left to the parameter docs.

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, the capability and its examples front-loaded, and the differentiator ('instead of running many search commands yourself') placed last as the call-to-action. No filler sentences.

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 seven-parameter delegation tool with no output schema, the description plus the fully covered schema gives an agent enough to call it correctly. What is missing is call-level behavior: expected latency, cost, and whether output is text or structured by default.

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

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

Schema description coverage is 100%, so every one of the seven parameters is already documented in the schema with rich detail (model routing, effort tier interaction, structured-output cost, slash_commands security). The description adds no parameter-level meaning beyond that, so the baseline 3 applies.

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

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

States a specific verb+resource (delegate codebase archaeology to the Antigravity CLI) and enumerates the concrete operations it covers: git log/diff/blame, wide greps, 'when/why did X change'. The scope is crisp enough to separate it from a generic delegate call, though no sibling tool (delegate, analyze_files, delegate_many) is named to sharpen the boundary.

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

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

'USE THIS instead of running many search commands yourself — it saves your context' gives an explicit when-to-use and an implicit when-not (don't hand-roll many search commands). It lacks any pointer to sibling alternatives for non-search delegation, so the routing guidance is clear but not complete.

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 burden and does well: it discloses the read-only default, that write:true permits file edits and command execution, that sandbox:true confines execution, and that refused actions surface as a denied-actions note. It omits auth/permission prerequisites and latency expectations beyond what the schema already notes.

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, purpose front-loaded, then safety defaults, then the denial behavior. Every clause earns its place with no redundancy.

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

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

For a nine-parameter delegation tool with no output schema, the description covers the safety-relevant behavior and the one notable return artifact (denied-actions note). It stops short of describing the normal success return shape, but the rich schema compensates for the parameter side.

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

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

Schema description coverage is 100%, so the schema already documents all nine parameters in detail. The description restates the write and sandbox semantics but adds no format, default, or interaction detail beyond what the schema provides; baseline 3 applies.

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 target resource: raw delegation to the Antigravity CLI for heavy tasks. It gestures at sibling differentiation ('tasks that don't fit the other tools') but never names the sibling (e.g. delegate_many or deep_search) that would be preferred, so an agent can't fully route on this alone.

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

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

Gives implied context ('heavy tasks that don't fit the other tools') but no explicit when-to-use/when-not or named alternatives. The agent must infer from the sibling list whether this or delegate_many/deep_search is appropriate.

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 a real trait: it runs behind the shared concurrency cap and queues rather than saturating quota. However it omits failure semantics (partial failures across N delegations), relative cost/latency, and how results and the disagreement report are returned — meaningful gaps for an 8-param fan-out tool.

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

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

Two tightly written sentences, both front-loaded with the most decision-relevant information (the two modes) followed by the queueing constraint. Nothing is redundant or padded.

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 a fully documented 8-param schema and no output schema, the description covers the essential decision context: the two invocation modes and the concurrency behavior. It stops short of describing how a council's disagreement report is surfaced or how errors are aggregated, which the schema cannot supply.

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

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

Schema description coverage is 100%, so the schema already explains every parameter (cwd, dirs, model, tasks, models, prompt, effort, slash_commands). The description adds no parameter-level guidance and notably never states that the `prompt`+`models` mode is mutually exclusive with the `tasks` mode, so it does not exceed the baseline.

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

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

The description gives a concrete verb and resource ('fan one question out to several models', 'fan several sub-tasks out to one model') and covers both operating modes, which is the key differentiator from the singular `delegate` sibling. It never names `delegate` explicitly, so the routing boundary is inferred rather than stated.

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

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

It clearly states the two conditions that select this tool: one question to many models (council), or many sub-tasks to one model. There is no explicit 'when not to use this / use delegate instead' statement, so the exclusion is left 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 real weight: it discloses that prior context lives on agy's side so nothing is resent, that the tool is read-only by default with `write: true` enabling file edits and command execution, and that slash_commands is off by default due to a prompt-injection risk. That security rationale is exactly the kind of context annotations would normally provide.

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

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

Front-loaded with the core purpose, then layered behavior and mode flags in short clauses; there is little filler. It runs slightly dense at four sentences with a mid-sentence caveat about agy's --effort handling, but every sentence adds callable information.

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

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

For a 9-parameter, no-output-schema tool with zero annotations, the description covers the non-obvious risks (mutation default, injection exposure, latency cost of `schema`) that an agent most needs. Less obvious parameters (cwd, dirs, effort) are documented in the schema, so the overall picture is adequate.

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

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

Schema coverage is 100%, so a 3 is the baseline, but the description adds genuine meaning beyond the schema for the two most consequential flags — `write` toggles mutating behavior and `model` enables cross-model second opinions on the same history. The remaining parameters are left to 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?

Opens with a specific verb+resource: 'Continue a previous Antigravity session by session_id', and immediately scopes it to follow-up questions about a prior delegation. That phrasing, plus the note that session_id is 'returned by every other tool', distinguishes it cleanly from delegate/delegate_many.

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?

Explicit context for use ('USE THIS for follow-up questions about a prior delegation') and a concrete alternate mode (pass `model` for a second opinion on the same history). It implies but never states the inverse exclusion — i.e. use `delegate` for brand-new work — so the routing guidance is strong but not fully closed.

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, and it does disclose real behavior: the choice is persisted ('saved and no tool asks again'), it is machine-global, and per-call overrides take precedence. It also documents the environment escape hatch (AGY_ASK_MODEL=false) and the routing fallback. It stops short of saying how to change or clear the choice later, so 4 rather than 5.

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

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

Front-loaded with the what and scope, then the required user-prompt flow, then the persistence/override rules. Every sentence carries information, though the last two sentences pack several related behaviors (persistence, per-call override, env bypass) tightly together.

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 0 required params, 100% schema coverage, no output schema, and no annotations, the description supplies the missing behavioral context: prompting the user, persistence, override precedence, and the bypass variable. What it omits is downstream lifecycle detail (re-invoking to change or reset the choice, and failure behavior), which is minor for this tool.

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

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

Schema description coverage is 100%, which sets a baseline of 3, but the description adds meaning beyond it: omitting arguments accepts the default (AGY_DEFAULT_MODEL / Gemini Flash High), and it clarifies how this stored choice interacts with per-call `model` arguments. It does not add format detail for the family-selector syntax, which the schema already covers.

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+resource+scope: 'Choose the model and reasoning tier every tool uses from now on, on this machine.' An agent immediately knows this sets a machine-wide, persistent configuration rather than invoking a model for one call. It is clearly separable from the analysis-oriented siblings (analyze_files, deep_search, delegate).

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?

Explicit when-to-use with sequencing: ask the user first ('proceed with the default, or change model or effort?'), then call this once. It names the invocation variants (no args = accept default; args = the chosen values) and the condition under which an alternative applies (an explicit `model` argument on a call wins for that call).

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 the delegation mechanism (an external Antigravity CLI backed by Gemini with web access), which is useful behavioral context, but says nothing about latency, cost, failure modes, or that the call spawns a separate agent process. For a delegated external call with zero annotation coverage, that is a notable 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?

Two sentences, no filler; the purpose comes first and the invocation trigger is front-loaded with a capitalized cue. Terse relative to a seven-parameter tool, but nothing in it 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 delegation tool with no output schema and no annotations, the description should say what comes back (a text answer, optionally structuredContent) and what a call costs in time. The schema hints at structured output and latency for one parameter only; the description leaves return shape and latency expectations unaddressed.

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

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

Schema description coverage is 100%, so the schema already documents query, cwd, dirs, model, effort, schema, and slash_commands in detail (including the cost warning on schema and the security note on slash_commands). The description adds nothing further about parameters, so the baseline 3 applies.

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

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

States a concrete verb and resource — delegating a web/documentation lookup to an external CLI agent with web access — and enumerates the kinds of questions it answers (library docs, API references, error messages, versions). It never names a sibling, so it misses explicit differentiation from deep_search or the generic delegate tools, but the purpose itself is unambiguous.

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

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

The second sentence gives a real trigger condition: use it when you lack information or the information may postdate your training data. That is clear, actionable routing logic. It stops short of stating when NOT to use it or pointing to deep_search/delegate as the alternative for non-web lookups.

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