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

With no annotations provided, the description carries the full behavioral burden. It discloses one important safety condition (source files must still match the base) but says nothing about what is mutated, atomicity, partial application behavior, permission requirements, or failure modes.

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 definition is a single front-loaded sentence with no wasted words. It is appropriately concise, though the terseness contributes to gaps covered under contextual completeness rather than conciseness itself.

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 mutation tool with no annotations, no output schema, and three parameters at 0% schema description coverage. A single sentence about the base-match guard is not enough to explain parameter meanings, partial application behavior, or what an agent should expect on success or failure.

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 explain all three parameters. It indirectly hints at expected_revision via 'match the base' and at task context via 'task changes,' but it never defines task_id or expected_revision explicitly and completely omits allow_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 description uses a specific verb and resource ('apply reviewed changes') and adds a clear guard condition ('if touched source files still match the base'). It distinguishes itself implicitly from siblings like discard_task_changes and get_task_changes, though it does not name those alternatives.

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 a clear precondition for use: changes must be reviewed and source files must still match the base. It does not explicitly state when not to use it or name alternatives such as discard_task_changes when the base has changed.

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 well: it discloses that Shuttle manages local servers automatically, that research/web access depends on the selected agent's capabilities, that read_only allows local files only and blocks web for Antigravity, and that full_access requires user authorization. It omits what happens after the call (whether it blocks/returns a result or requires get_result), which is the main remaining 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?

Front-loaded and dense with useful constraints, but the Russian sentence 'Делегирование: исследование, ревью, реализация, второе мнение' duplicates the English purpose list and earns no place, and several policy caveats are packed into one long paragraph.

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 6-parameter delegation tool with no annotations and no output schema, the description covers target selection, safety policies, routing to siblings, and user authorization expectations. It stops short of explaining the call's lifecycle (sync vs async, how results are retrieved), which is the main item an agent might still need.

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

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

Schema coverage is 100%, so the baseline is 3, but the description adds selection guidance beyond the schema: inspect get_agent_info before selecting an enforceable tool policy, preserve the user's explicit agent and model, choose web_research for Antigravity web research, and use least sufficient policy. These add real decision meaning to agent_id and tool_policy.

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 precise verb and resource ('Delegate research, code review, implementation or a second opinion to a local AI agent') and enumerates the concrete targets (antigravity, codex, opencode, claude_code, configured agent_id). An agent can distinguish this from ask_antigravity/ask_codex and from list_agents/get_agent_info 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?

Explicitly states when to use ('for an actual request to have another agent perform work') and when not to ('Answer general explanations and advice directly; mentioning an agent or a second opinion alone does not request delegation'). It also names the alternative for long-running work ('Use submit_task for long work') and instructs preserving the user's explicit agent/model.

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 does disclose useful policy details: default read-only mode, workspace_write for edits, blocked shell/MCP/subagents, and automatic permission hooks. It still omits key operational behavior such as whether delegation is synchronous, what is returned, and how timeout or failure conditions behave.

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-loads the core action plus the main policy choice. The remaining sentences add relevant permission context without obvious fluff, though the structure could more clearly separate purpose from parameter guidance.

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 delegation tool with no annotations and no output schema, the description is incomplete. It does not document most parameters, does not distinguish sibling delegation tools, and does not explain return behavior or sync/async semantics.

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, so the description must compensate, but it only implies values for tool_policy. It does not explain model, workspace, reasoning_effort, turn_timeout_seconds, or how prompt is used, leaving most parameters undocumented.

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

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

The description says 'Delegate to Antigravity,' which gives a verb and target but does not explain what Antigravity is or how this differs from sibling tools like ask_agent or ask_codex. Purpose is minimally understandable but vague because the target resource is opaque.

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 provides clear guidance for choosing between read_only and workspace_write when file edits are needed. However, it gives no guidance on when to use ask_antigravity versus ask_agent, ask_codex, or the task-based siblings, so tool-selection guidance is only implied.

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

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

With zero annotations, the description carries the full behavioral burden. It discloses one important trait, auto-launching the A2A server when absent, but says nothing about permissions, sync vs async execution, expected latency, or what a call returns.

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 server-launch caveat. Nothing is wasted, though the terseness crosses into 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 five-parameter tool with no annotations, no parameter docs, and no output schema, the description is far too thin. An agent lacks the information to populate four of the five parameters 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%, so the description must compensate and it largely does not. It addresses only 'model' ('omit unless requested') while leaving prompt, workspace, tool_policy, and reasoning_effort completely 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 target ('Delegate to Codex') and distinguishes itself from the generic ask_agent by naming a concrete backend. However, it never explains what Codex is or what capability the delegation provides, so an agent must infer the payoff.

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 only guidance is 'Omit model unless requested,' which is a parameter hint, not a when-to-use rule. Nothing says when to pick this over ask_antigravity, ask_agent, or submit_task, 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 burden, and it does disclose two useful traits: cancellation blocks on backend cleanup and repeat calls are safe. It does not state what happens to the task's result, whether the task must be in a particular state, what errors occur for unknown task IDs, or any authorization 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 efficient sentence with no filler, and the core action is front-loaded before the safety note. Given this tool has no annotations and an undocumented parameter, however, it is arguably too terse.

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 cancellation tool, the description covers the action, the blocking cleanup, and idempotency. It is still incomplete regarding post-cancel task state, error behavior, and the origin of task_id, and no annotations or output schema exist to fill those 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 coverage is 0%, and the description says nothing about task_id beyond the name. Even though task_id is fairly self-explanatory, the description does not say where to obtain it (e.g., from submit_task) or whether it must be a currently active task.

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: "Stop the delegated task." An agent can distinguish this from siblings like get_result, wait_task, or discard_task_changes, but the description does not explicitly name or contrast with any alternative.

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

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

There is no explicit when-to-use or when-not-to-use guidance, and no alternatives are named. "Repeated cancellation is safe" hints at idempotent usage but does not tell the agent whether to cancel versus wait or fetch results, nor whether the task must be running first.

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 the useful non-blocking trait ('without waiting for the worker'), but it does not state whether the snapshot is cached/stale, what happens if the task_id is unknown, what permissions are needed, or what the response contains.

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

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

The description is a single front-loaded sentence with no filler. It is efficient, though its brevity contributes to the gaps in behavior and parameter explanation rather than fully earning its place as a complete definition.

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 low-complexity read tool, but it has no annotations, no output schema, and an undocumented required parameter. The description communicates the non-blocking behavior but leaves out return values, error behavior, and parameter meaning, which are not covered elsewhere.

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 has 0% description coverage and there is one required parameter, task_id. The description never mentions task_id or its meaning, so it adds no semantic guidance beyond the parameter's self-descriptive 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 gives a specific verb and resource: 'Read the current task snapshot.' The phrase 'without waiting for the worker' distinguishes it from the blocking sibling wait_task, though it does not explicitly name or contrast with other status-oriented siblings like get_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 implies when to use this tool through the contrast with waiting for the worker, suggesting non-blocking status checks. However, it does not state when to prefer this over siblings such as get_result, get_task_changes, or get_events, nor does it give explicit 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 of behavioral disclosure. It states that a saved change and owned worktree are deleted, which identifies the destructive scope, but it omits irreversibility, permission requirements, task state after discard, and what the operation returns.

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, and the destructive action is stated first. It is concise, though the sparse structure leaves important behavior unstated for a destructive tool.

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

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

The tool is a destructive mutation with no annotations, no output schema, and an undocumented required parameter, so the description needs to do more. It identifies what is deleted but does not cover usage conditions, parameter meaning, irreversibility, or expected outcome.

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 never explains the required task_id parameter or how a task should be identified. The schema alone provides only the parameter name and type, so the description does not 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 states a specific verb (delete) and resource (an isolated task's saved change and owned worktree), so the tool's purpose is clear. It implicitly contrasts with sibling tools like apply_task_changes and get_task_changes, but it does not explicitly name or differentiate those alternatives.

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 guidance on when to use this tool versus apply_task_changes, cancel_task, or other sibling tools. The word 'Explicitly' hints that deletion is intentional, but there is no when-to-use condition, exclusion, or alternative routing.

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 that the local server is managed automatically (a side effect), that no model turn is consumed, and that the data is live rather than cached. It stops short of documenting permissions, failure modes, or the shape of the returned metadata.

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?

It is four short sentences with the primary purpose and the delegation use case front-loaded, and nothing is wasted. The hard line breaks and missing terminal structure make it slightly harder to scan than ideal, but there is 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?

For a read-only inspection tool with a fully documented two-parameter schema, the description covers purpose, timing, cost, and the sibling alternative. Without an output schema, a brief word on what the returned metadata looks like would close the last gap.

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 both agent_id and workspace are already documented with their accepted values and fallback semantics. The description only restates the provider list already present in the schema and adds no new meaning, 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?

The description uses a specific verb ('Inspect') and enumerates the resources inspected: live models, account quota, and enforceable tool policies, scoped to named providers. It explicitly contrasts with list_agents ('offline inventory'), so an agent can distinguish it from siblings without opening the 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?

It names the triggering context ('before delegating research, review, implementation or a second opinion') and the exclusion plus alternative ('use list_agents for offline inventory'). It also clarifies the cost model ('without a model turn'), which is decision-relevant 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 burden. It implies a read-only, no-turn operation and enumerates what is returned, but says nothing about permissions, quota implications, or whether the 'account quota' read has any cost or freshness caveat.

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 resource contents are listed compactly and the differentiator is placed at the end where it reads naturally.

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 exists, so the description's enumeration of returned data is helpful, and no annotations means the safety profile falls to it (reasonably implied as read-only). The undocumented 'workspace' parameter and absent quota/permission caveats leave 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?

The single 'workspace' parameter has 0% schema description coverage and no mention in the description, so an agent gets no guidance on what it scopes or what the default (null) means. The description 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 ('Read') plus the exact resource contents: models, effort options, and account quota. The phrase 'without an agent turn' implicitly separates it from the ask_antigravity sibling, though no sibling is named explicitly.

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

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

'Without an agent turn' implies this is the cheap, side-effect-free lookup as opposed to asking the agent, which is a usable contextual cue. However, it neither names the alternative (ask_antigravity) nor states explicit when/when-not conditions.

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

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

With no annotations, the description carries the full burden; it does disclose one genuinely useful trait — that it consumes no agent turn (no cost/latency/side effects on the conversation). It omits whether the call requires authentication, which account/workspace context it is scoped to, and any rate-limit behavior, leaving meaningful gaps for an unannotated 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; the verb and returned data lead, and the differentiator trails. 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?

The description usefully enumerates what comes back, partially standing in for the absent output schema. But with no annotations and an entirely undocumented workspace parameter, an agent cannot tell whether to pass a workspace or how that changes the result.

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 never mentions the single optional 'workspace' parameter, so there is no indication of what a workspace value does (presumably scoping which account's models/quota are read). The one parameter that exists is undocumented everywhere.

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 (Read) plus the exact resources returned: current models, supported efforts, and account quota. The qualifier 'without an agent turn' implicitly separates it from ask_codex/ask_agent, so an agent can distinguish it from siblings 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?

'without an agent turn' gives clear context for choosing this over conversational siblings like ask_codex — it is the cheap, no-side-effect lookup path. It stops short of explicitly naming an alternative tool or stating exclusions, so it lands below the top mark.

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 must carry the full behavioral burden. It states that it reads full JSON data and names a precondition, but it omits critical pagination behavior (the limit/cursor defaults of 60000 and 0), error handling, and whether the 'full' data is paged or complete in one response.

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 single sentence is front-loaded and free of waste, though for a four-parameter tool with zero schema documentation it is arguably too terse to be 'appropriately sized.'

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 lack of annotations, no output schema, and 0% parameter coverage, the definition is significantly incomplete. It does not explain how to paginate, what the response format looks like, or how it relates to sibling 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% – none of the four parameters have descriptions in the schema. The description mentions a 'journal event' but does not map task_id, seq, limit, or cursor to their meanings or explain their roles.

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 a specific verb ('Read') and resource ('full JSON data for a journal event') plus a triggering condition ('data_truncated=true'). It does not distinguish this tool from the related get_events sibling, leaving the agent to infer that this one fetches a paginated slice of a single event.

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 condition 'with data_truncated=true' implies when to use the tool, but there is no explicit when-not guidance and no comparison to alternatives like get_events or get_transcript.

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 add useful behavior: the journal is ordered, paging is cursor-based via an end offset, and the response includes total_size used to poll for new events. It says nothing about whether the call blocks, how limit interacts with the cursor, permission or auth requirements, or what happens if task_id is unknown.

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

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

Two short sentences with no filler, and the core purpose is front-loaded. It is on the edge of being too terse for a three-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 three-parameter read tool with zero annotation coverage, no output schema, and 0% parameter documentation, the description leaves too much unspecified: parameter meanings, return shape beyond total_size, and the difference from get_event_page. It gestures at the polling pattern but does not complete the picture.

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 all three parameters (task_id, limit, cursor) are undocumented in both schema and description. The description hints at cursor semantics through the polling note, but never explains what task_id identifies or what limit does, leaving the caller to guess.

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

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

States a specific verb and resource: 'Read Shuttle's ordered event journal.' That is clear about what the tool returns (an ordered event stream). It does not distinguish itself from the sibling get_event_page, which sounds like it also reads events, so an agent cannot tell the two apart from the description alone.

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

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

The second sentence implies an incremental-polling workflow ('Save total_size to poll after the current end'), which is real usage guidance. But there is no explicit statement of when to prefer this over get_event_page or get_transcript, and no exclusion or prerequisite 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, so the description carries the full behavioral burden. It usefully discloses that pages are bounded and that pagination terminates when next_cursor is null, but it says nothing about error behavior for an unknown task_id, ordering of results, or whether repeated reads are stable. It also names a field, next_cursor, that does not exist in the input schema (the parameter is cursor), which creates confusion about the response shape in the absence of an 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?

One short clause pair, front-loaded with the action and followed by the loop condition; there is no filler. It is terse rather than padded, though the terseness leaves gaps elsewhere.

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 no annotations, no output schema, and 0% parameter coverage, a single sentence is not enough. The agent is not told what a 'result' contains, how to interpret limit/cursor, or when this tool is the right read versus its many siblings.

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

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

Schema description coverage is 0%, so the description must document task_id, limit, and cursor, and it documents none of them. It never explains that limit controls page size (default 60000) or that cursor is an offset (default 0), and the only hint at pagination uses a different name than the actual parameter.

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 read of a paginated 'result page', which is a verb+resource, but 'result' is never tied to a task or agent, so it is unclear how this differs from get_transcript, get_events, or get_event_page in the sibling set. An agent must guess which of the several read tools returns task results.

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 only guidance is the pagination loop ('follow next_cursor until it is null'), which is a how, not a when. Nothing says when to prefer get_result over get_transcript, get_events, check_task, or get_event_page, and no prerequisites (e.g., a completed task, a valid task_id) 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 must carry the behavioral load, and it does add one genuinely useful fact: this is non-mutating. Beyond that it says nothing about what "saved changes" means, whether the task must be in a particular state, or whether results persist.

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 read-only guarantee is placed immediately after the purpose. It is efficient, though the compression leaves key distinctions unstated.

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 annotations, no output schema, and an undocumented required parameter leave too much unanswered for an agent to call this confidently. Minimum completeness would require clarifying how this differs from get_task_diff and what task_id must reference.

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 offers no explanation of task_id at all. Since the schema does no work here, the description should have compensated, even if only to say task_id identifies a previously submitted task.

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 ("Describe") and resource ("an isolated task's saved changes"), so an agent knows it reads pending changes for a task rather than executing them. It does not, however, distinguish itself from the sibling get_task_diff, which sounds near-identical in purpose.

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 "no files are modified" implicitly routes the agent here instead of apply_task_changes for inspection, but that contrast is never made explicit. There is no stated when-to-use, no comparison to get_task_diff, and no prerequisite information.

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 implies read-only behavior via 'Read' and reveals two real traits — the payload is a binary patch and results are paged — but says nothing about truncation signaling, behavior when the task has no diff or is not finished, or permissions.

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

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

A single tight sentence with the resource and scoping front-loaded and no filler. It is efficient rather than bloated; brevity is the only concern, not waste.

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 annotations, no output schema, and zero parameter documentation, the description should explain the binary patch format a caller will receive and how to page through it. Those gaps leave an agent guessing about the most consequential aspects of the call.

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 all three parameters (limit, cursor, task_id) are undocumented in both schema and description. 'Bounded page' only weakly gestures at limit/cursor, leaving the unit of limit (bytes vs. lines, default 60000), cursor continuation semantics, and task_id meaning 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 (Read) and resource (an isolated task's Git binary patch) with scope qualifier (bounded page). An agent can tell this returns a raw patch rather than a structured change list, implicitly distinguishing it from get_task_changes. It stops short of naming the sibling it is not.

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 guidance on when to call this instead of get_task_changes or get_result, and no prerequisites (e.g. must the task be completed?). The phrase 'isolated task' hints at context but never tells the agent which situation selects 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 provided, the description carries the behavioral burden. It discloses that the operation is a read and warns that “status updates may be absent,” which is useful, but it does not describe permissions, pagination behavior, ordering, or return characteristics.

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 states the core action and adds one relevant caveat efficiently.

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 zero annotation coverage, no output schema, and 0% schema description coverage across three parameters, the description is too thin. It does not explain pagination inputs or what “artifacts” and “task history” include, leaving the agent to infer key invocation details.

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 hints at pagination through the word “page” and implies task_id via “task history,” but it does not explain limit, cursor, defaults, or the meaning of task_id.

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 a specific verb and resource: “Read a page of A2A task history and artifacts.” It clearly distinguishes the tool from task-mutating siblings by framing it as reading history/artifacts, though it does not explicitly name alternatives such as get_events or get_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?

There is no explicit guidance on when to use this tool versus siblings like get_events, get_result, or get_task_changes. The description implies usage by saying it reads task history and artifacts, but it provides no exclusions or alternative-selection 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?

With no annotations, the description carries the full burden and does so well: it discloses that no agent processes are started, no models are contacted, and authentication is not verified — i.e., a cheap, side-effect-free read. It does not mention latency or whether results are cached, which is the only remaining behavioral 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 key capability and the negative-scope clause are front-loaded, and the routing hint to get_agent_info sits right where it is needed. The stray Russian sentence ("Поиск агентов для делегирования задач.") duplicates the first line without adding meaning, and the when-not sentence is slightly verbose, but overall it is tight.

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 output schema and no annotations, the description does the work by naming the returned fields and the explicit non-effects of the call. It stops short of describing the output shape (how errors or availability are represented), which would fully close the gap given the absent 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?

The tool takes zero parameters, so there is nothing for the description to disambiguate; baseline for a parameterless tool is 4. The description correctly conveys that no filters exist by framing the result as the full local inventory.

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 ("Discover local Antigravity, Codex, Claude Code, OpenCode and configured ACP agents") and names exactly what the listing contains (agent_id, command availability, configuration errors). It explicitly contrasts itself with the sibling get_agent_info, so an agent can distinguish the two without opening either 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 when-to-use ("when asked to discover actual available local agents or while preparing authorized delegation"), an explicit alternative ("Use get_agent_info for live readiness, models and tool policies"), and an explicit when-not ("General explanations and advice ... do not require an inventory of the user's installed agents"). Nothing 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 the full burden and does so: it discloses that the call is asynchronous ('Returns a task ticket immediately'), that Shuttle manages local servers, that full_access 'requires user authorization', that Antigravity read_only 'allows local files only' and cannot reach the web, and that isolated workspace_mode 'creates a detached Git worktree' whose changes should be reviewed before apply_task_changes. These are exactly the side-effect and permission facts an agent needs before invoking.

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?

Most sentences are load-bearing and the routing constraint is front-loaded, but the description is a dense wall of clauses and includes a full Russian restatement of the first sentence ('Делегирование: исследование, ревью, реализация, второе мнение') that duplicates content already stated in English. That redundancy costs it a point without making it unreadable.

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 asynchronous tool with no output schema, the description supplies the missing return-lifecycle information (ticket now, poll via check_task/wait_task, retrieve via get_result) and points at get_agent_info and apply_task_changes for the surrounding workflow. Nothing needed to call it correctly is absent.

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

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

Schema coverage is 100%, so the baseline is 3; the description still adds real value beyond the schema by stating 'Reuse request_id when retrying submission', 'Preserve the user's explicit agent and model', 'least sufficient supported policy', and directing model/reasoning_effort discovery through get_agent_info rather than guessing values.

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-plus-resource ('Delegate research, code review, implementation…to a local AI agent') and enumerates the concrete agents available. It separates 'actual request to have another agent perform work' from answering directly, though it never explicitly contrasts submit_task with the sibling ask_agent, which is the nearest alternative for lightweight queries.

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 explicit when-to-use ('actual request to have another agent perform work', 'long work'), when-not-to-use ('mentioning an agent or a second opinion alone does not request delegation'), and prerequisite routing (inspect get_agent_info before selecting a tool policy, choose web_research for Antigravity when advertised, preserve the user's explicit agent and model). It also prescribes the follow-on sequence: check_task/wait_task, then get_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 full behavioral burden. It usefully discloses that expiry returns a snapshot and does not cancel work, but 'separate budget' is unexplained and there is no mention of blocking behavior, permissions, or side effects.

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?

It is a single efficient sentence with the key safety point front-loaded. The phrase 'separate budget' is cryptic, but the overall structure is compact and has no wasted 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 two-parameter task-waiting tool with no annotations and no output schema, the description is thin. It omits task_id semantics, timeout behavior, what the snapshot contains, and how this differs from sibling 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 must explain both parameters. It never mentions task_id, and 'expiry' only loosely implies timeout_seconds without explaining its relation to the default or snapshot behavior.

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 verb 'Wait' is clear, and the description adds behavioral detail ('expiry returns a snapshot', 'never cancels work'), but it never states the resource explicitly or says it waits for task completion. 'Separate budget' and 'snapshot' are undefined, and no sibling tool is distinguished.

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 guidance on when to choose wait_task over check_task, get_result, or cancel_task. It implies a safe wait through 'never cancels work', but does not say when waiting is preferable to polling or fetching results.

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