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 a read-only extraction ('reads... distills'), which is useful, but says nothing about cost/latency for 100k+ line inputs, whether there are size or path restrictions, whether results are cached, or what happens on unreadable paths. For a tool that ingests very large inputs, that is a meaningful 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 that states the input scale and the output shape with no filler. It is efficient, though it is arguably too terse given the undocumented parameters.

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?

An output schema exists, so return values need not be explained. But with zero annotation coverage and 0% schema description coverage, the agent is left without knowing input format conventions or operational constraints for a tool that processes very large inputs — the two areas the description should have closed.

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% — both parameters have only titles and no descriptions. The description implies 'directory_or_log' is a path or raw log and 'issue_description' is a question, but it does not clarify format (absolute path? glob? inline content?) or how the issue description shapes the distillation. The description does not compensate for the schema 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?

Names a specific verb pair (reads/distills) and concrete resources (massive directories, 100k+ line logs), plus the output form (AST code blocks, pinpointed issue context). An agent can tell this is a context-reduction/extraction tool rather than a task runner or verifier like most siblings. It stops short of explicitly distinguishing itself from the nearest sibling (e.g., call_codex_architect) that might also analyze code.

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 phrases 'massive directories' and '100k+ line logs' imply a size threshold for when the tool is appropriate, which is a usable trigger. However, there is no explicit when-not-to-use guidance, no statement about small inputs, and no reference to any alternative sibling tool for context gathering.

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, and it does disclose non-obvious behavior: the tool rejects calls against busy chats, after model changes, and with unsent drafts, and the optional thread id enables watching the new round. It still omits whether the correction mutates or appends to prior state and what error feedback looks like, but the refusal semantics are genuinely useful.

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 with the core action and prerequisite front-loaded and zero filler. The refusal clause is compressed to near-telegraphic form ('unsent drafts'), which trades a little precision 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?

An output schema exists, so return values need not be explained, but for a 4-parameter tool with 0% schema coverage and no annotations the description is thin: it never says what the correction does to prior task context or clarifies workspace_path vs. task_id. Adequate to call correctly, incomplete to call confidently.

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 4 parameters, so the description has to compensate. It explains notify_codex_thread_id's purpose ('watch the new round') and ties task_id/workspace_path to 'the same completed GUI task', but prompt is undocumented (append vs. replace semantics unknown) and workspace_path's relationship to task_id is never clarified.

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: sending corrections to an already-completed GUI task, keyed by task_id. It implicitly distinguishes itself from antigravity_gui_start_task (new tasks) but never names a sibling, so the differentiation must be inferred from 'same completed GUI task'.

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 'the same completed GUI task' establishes the prerequisite that a prior completed task exists, and the refusal list ('busy chats, model changes, unsent drafts') gives concrete when-not-to-use conditions. It stops short of naming an alternative tool to use when those refusals apply.

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 mentions interacting with the 'real Antigravity GUI' and optionally notifying an existing Codex chat, but it omits critical behaviors such as whether the GUI is locked or mutated, what happens to existing conversations, required permissions, and whether the call blocks until completion.

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

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

The description is three short sentences and front-loads the main action. It is efficient, though 'Optionally watch completion' is somewhat cryptic and not tied to a visible parameter.

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

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

This is a complex tool with 7 parameters, zero schema description coverage, and no annotations, yet the description does not compensate with parameter semantics or behavioral detail. The existence of an output schema reduces the need to explain return values, but the gaps around action behavior and most parameters remain significant.

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

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

Schema description coverage is 0% for all 7 parameters. The description only hints at the purpose of prompt/workspace via 'scoped task' and notify_codex_thread_id via 'notify the exact existing Codex chat'; it says nothing about target_id, gui_project, expected_model, or new_conversation, 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 uses a specific verb and resource ('Send a scoped task to the real Antigravity GUI'), making the core action clear. It partially distinguishes itself from CLI/API tooling by stating 'No CLI/API fallback for Antigravity,' but it does not differentiate from siblings like antigravity_gui_followup or codex_gui_ask.

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

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

Usage is implied by 'Send a scoped task' and the note about no CLI/API fallback, but there is no explicit guidance on when to use this tool versus siblings such as antigravity_gui_followup, antigravity_gui_status, or codex_gui_ask. No prerequisites or exclusions are stated.

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

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

With no annotations, the description carries the full burden; 'Inspect' implies a read-only operation and 'No CLI or API fallback' signals it fails if the GUI is unavailable, which is useful context. It does not state permission requirements, latency, whether it can disturb the running GUI, or whether the unsent draft is sensitive to read.

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

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

Two short sentences, front-loaded with the verb and resource, followed immediately by the fields returned and the no-fallback constraint. 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?

An output schema exists, so return-value documentation is unnecessary, and the note about no fallback is a real completeness gain. However, the undocumented target_id and the absence of routing guidance against the dense sibling set leave the definition only minimally sufficient.

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

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

Schema description coverage is 0% and the single optional 'target_id' parameter is never mentioned in the description. The agent gets no guidance on what a target identifies (window? session? profile?) or what omitting it does.

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

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

States a specific verb ('Inspect') and resource ('the real local Antigravity GUI') plus the exact fields examined: current model, busy state, unsent draft. 'No CLI or API fallback' implicitly separates it from the API-driven siblings, though it never names antigravity_gui_task_status or codex_gui_status directly.

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

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

Usage is only implied: the phrase 'No CLI or API fallback' suggests this is the tool to use when you need true GUI state rather than an API surface. There is no explicit when-to-use, when-not-to-use, or named alternative among the many GUI/task siblings.

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 exist, so the description carries the full burden. It does make two non-obvious disclosures: "owned" implies an ownership/authorization precondition on the task, and it explicitly warns that ready_for_review means the turn ended rather than that code or tests passed. It says nothing about behavior for a missing/foreign task id, or whether the read blocks.

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 zero filler, and the semantic caveat is front-loaded right after the action statement. It is terse to the point of under-specification, but nothing written 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?

An output schema exists, so return shape needn't be described, and the ready_for_review note usefully disambiguates an output value. However, with no annotations, two fully undocumented required parameters, and no differentiation from near-identical status siblings, the definition is not complete enough for confident invocation.

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

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

Both parameters (task_id, workspace_path) are required with 0% schema description coverage, so the description is the only source of meaning and it explains neither. "Owned" hints that task_id must belong to the calling workspace, but the format and relationship between task_id and workspace_path are never stated.

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?

"Read the owned GUI task" gives a verb (read) and a resource (GUI task), so the general purpose is inferable. But the sibling set contains antigravity_gui_status and codex_gui_status, and the description never explains how a per-task status read differs from those. The agent is left to guess from the parameter names 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?

There is no statement of when to call this versus antigravity_gui_status, codex_gui_status, or codex_gravity_completion_status, and no note on whether it is meant to be polled or called once. The only guidance is interpretive (what ready_for_review means), not situational.

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 useful behavior: ffprobe metadata extraction, optional model analysis, and status=partial when only metadata is available. However, it says nothing about file access permissions, supported formats, size limits, or failure modes for a tool that reads local files.

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 core action comes first, followed by the optional model behavior and the partial-result condition. Every sentence adds distinct 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?

An output schema exists, so return values need not be explained. Still, the definition leaves both required parameters semantically undefined and gives no alternative-tool guidance, which is a meaningful gap for a two-parameter media inspection 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 0%, so the description must compensate for both required parameters, but it does not explain file_path at all and never mentions focus_query. The agent gets no semantic guidance for how to supply either argument beyond generic names.

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

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

The description states a specific verb and resource: read local video/audio/image metadata via ffprobe, with optional model analysis. This is clear enough to distinguish it from most siblings, though it does not explicitly contrast itself with call_antigravity_multimodal or other media-related tools.

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

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

The description explains the internal condition for model analysis and partial results, but gives no guidance on when an agent should choose this tool over alternatives such as call_antigravity_multimodal. There are no exclusions or 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?

No annotations exist, so the description carries the full disclosure burden, and it discloses almost nothing. It doesn't say that an arbitrary shell command is executed (a significant safety consideration), whether a browser is launched, what happens if ui_url is omitted, or what artifacts/screenshots come back.

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 tightly-worded sentence with the primary action front-loaded and nothing wasted. It is efficient, though the terseness is partly what creates the gaps captured in other dimensions.

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?

An output schema exists, so return values need not be described, but this is a compound tool with four parameters at 0% coverage and no annotations. Given that complexity, one sentence is not enough for an agent to invoke it confidently or safely.

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 all four parameters (cwd, ui_url, timeout, test_command) are undocumented in structured form. The description implies test_command and vaguely gestures at ui_url via 'multi-viewport UI layout', but says nothing about cwd or the 60-second timeout default, leaving most parameters 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 names two concrete actions (execute a test command in a terminal, inspect UI layout across multiple viewports), so an agent knows the resource and the verbs. It does not, however, distinguish this from the sibling 'call_antigravity_verifier', which sounds like it does the same verification work, leaving ambiguity about which to pick.

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

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

There is no statement of when to use this tool, when not to, or how it relates to the near-identically named sibling. The agent must infer that test_command triggers the terminal step and ui_url triggers the viewport inspection, without guidance on whether both are normally supplied together.

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 exist, so the description carries the full behavioral burden, yet it discloses almost nothing: no indication of whether the call is synchronous, what permissions/subscription checks occur, whether it hits rate limits, or what side effects it has. The only behavioral hint is 'via active subscription,' which implies an auth prerequisite but is not elaborated.

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 short (one sentence), but brevity here is under-specification rather than conciseness. The leading phrase 'Symmetrical tool' is cryptic jargon placed in the most prominent position, and the rest of the sentence is vague about the actual operation.

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 presence of an output schema means return values needn't be explained, but everything else is missing: parameter semantics, selection guidance against near-duplicate siblings, and any behavioral context for a tool with zero annotation coverage. An agent could not reliably call this tool from the definition alone.

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

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

Schema description coverage is 0% for two required parameters (media_path, instruction), and the description adds no information about either. It does not say what path formats are accepted, whether URLs vs local paths work, or how the instruction is interpreted/constrained.

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 Codex requests Google Antigravity (Gemini Flash) for 'media or context distillation,' which gives a rough sense of the resource and intent. However, it never states what the call actually produces or returns, and the opaque phrase 'Symmetrical tool' adds no clarity for an agent that lacks context on the Codex/Antigravity pairing.

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

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

There is no when-to-use or when-not-to-use guidance, and no alternatives are named. This is especially costly given siblings like antigravity_inspect_media and antigravity_distill_context that appear to cover exactly the 'media or context distillation' capabilities mentioned, leaving the agent unable to choose between 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 carries the full behavioral burden and falls short: it doesn't say whether this executes a shell command, whether it is blocking, what permissions or environment it needs, or how the visual regression component behaves. It only gives a high-level purpose.

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 compact and front-loads the core action, but the 'Symmetrical tool:' fragment is unexplained noise and the brevity comes at the cost of under-specification rather than efficiency.

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?

Even though an output schema exists (so return values needn't be described), the definition is incomplete for a 2-param verification tool: 0% schema coverage, no annotations, no usage guidance, and no differentiation from the near-identical sibling.

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, but it only loosely maps to the params (terminal → test_command, visual → ui_url). It gives no format, syntax, or meaning for test_command and no explanation of what ui_url expects or when to supply it.

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 action and resource: 'Request Antigravity terminal verification and visual regression checks.' An agent can tell it runs verification and visual checks, but it does not distinguish this from the sibling antigravity_verify_and_screenshot, which sounds nearly identical. The 'Symmetrical tool' preamble adds no clarifying power.

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 this vs antigravity_verify_and_screenshot or call_antigravity_multimodal, and no exclusions or prerequisites. The word 'Symmetrical' hints at a counterpart but never names or explains the distinction, leaving routing entirely 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 disclose the key behavioral traits: read-only, no file edits, no persistent chat, no synthetic fallback, uses the configured model. It omits operational traits an agent would want for a potentially slow external call (the 300s default timeout suggests long runtime), and says nothing about auth prerequisites beyond 'signed-in' or any rate/cost limits.

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 core action and scope, with the negative constraints packed into the second sentence. 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?

An output schema exists, so return values needn't be explained, and the no-side-effects profile is covered. But for a 4-parameter tool with 0% schema coverage and no annotations, the description leaves too much undocumented — parameter meanings and disambiguation from codex_gui_ask are the notable holes.

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 4 parameters, so the description must compensate and it does not — prompt, timeout, code_context, and workspace_path are never mentioned. An agent gets no guidance on what to put in code_context versus workspace_path, or how timeout interacts with the call's bounded nature.

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 ('Ask the real signed-in Codex CLI') plus the domain ('code/architecture answer') and scope ('bounded read-only'). It also implicitly distinguishes itself from synthetic/provider-API variants, but never names the obvious overlapping sibling codex_gui_ask, so the agent must guess between the two.

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

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

Usage is only implied: the reader infers 'use for read-only code/architecture questions.' There is no explicit when-to-use statement, no when-not-to-use, and no named alternative such as codex_gui_ask or call_antigravity_verifier, which matters with this many sibling 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?

No annotations are supplied, so the description must carry the full behavioral burden. It clarifies cancellation scope by excluding Antigravity cancellation and Codex message recall, but it omits permissions, idempotency, effect on the watch, prerequisites, and error behavior.

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

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

Two sentences, front-loaded with the operation, and the exclusion clause is compact. There is no filler or redundant restatement.

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 output schema covers return values, but the description leaves required parameter semantics and cancellation behavior undocumented, and there are no annotations to compensate. For a mutation tool with two required parameters, this is incomplete.

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?

Both parameters are required with 0% schema description coverage, and the description never names watch_id or workspace_path. The word 'watch' weakly implies watch_id, but workspace_path is completely unaddressed 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 first sentence gives a specific verb ('Cancel') and resource ('a completion watch'), and the second rules out two nearby confusions: cancelling Antigravity or recalling an already submitted Codex message. The action is unambiguous against siblings such as codex_gravity_watch_completion and codex_gravity_completion_status.

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 explains what the tool does and explicitly states two things it does not do, which gives clear usage context and exclusions. However, it never says when to check codex_gravity_completion_status first or what alternative to use instead, so it stops short of full when/when-not/alternatives guidance.

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

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

With no annotations, the description does good work on two fronts: it discloses that the call is non-mutating ('without sending a message') and pre-empts a costly misreading of the `notified` state (desktop accepted a follow-up, not review success). It still leaves the wider state machine undocumented — other possible status values and behavior for invalid/expired watch_id are unstated.

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, no filler, and the disambiguating scope ('without sending a message') is front-loaded before the state-semantics caveat. Every clause earns its place.

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

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

An output schema exists, so return values need no explanation, and the notified caveat covers the main interpretive risk. But for a two-required-parameter, zero-annotation, zero-coverage tool, the missing link between watch_id and the tool that creates watches is a real gap for correct invocation.

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

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

Schema description coverage is 0%, so the description should compensate and does not: it never says where watch_id originates (presumably from codex_gravity_watch_completion) or what form workspace_path takes. The parameter names alone are the only guidance an agent gets.

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: reading a persisted completion watch, explicitly in a non-blocking way ('without sending a message'). This implicitly separates it from codex_gravity_watch_completion (await/trigger) and codex_gravity_cancel_completion, though neither sibling is named.

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 'without sending a message' hints this is a polling/lookup call rather than an await, but the description never states when to choose this over codex_gravity_watch_completion or cancel_completion, nor what to do if the watch is unknown or expired. Usage must be inferred.

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

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

With no annotations, the description carries the full burden and does add real signal: it blocks while Codex is busy, will not silently retry uncertain delivery, and grants exactly one follow-up per round. But it leaves key behavior unexplained — whether the watch persists after the call returns, what occurs at timeout_seconds, and whether re-invocation is idempotent or duplicates a watch.

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 with the primary action front-loaded and no filler. The density is high but each sentence conveys distinct information; only the 'detached completion watch' phrasing asks extra parsing work of the reader.

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?

An output schema exists so return values need not be described, and the blocking/no-retry semantics are covered. Still, for a six-parameter, unannotated, state-mutating tool the description omits polling/timeout behavior and lifecycle details, leaving the agent under-informed before invoking it.

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 and largely does not. It only indirectly maps to task_id and codex_thread_id; resume, poll_seconds, timeout_seconds, and workspace_path receive no meaning at all, leaving half the surface undocumented in both places.

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 pair ('Register/resume') and resource ('a detached completion watch'), scoped to an owned Antigravity task and an existing Codex thread UUID. It implicitly distinguishes itself from the status/cancel siblings by framing the action as registration/resumption, though it never names them and the term 'detached completion watch' is jargon an agent must infer.

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 implies prerequisites ('owned Antigravity task', 'exact existing Codex thread UUID') and signals the authorization role ('Explicitly authorizes one completion follow-up for this round'). However, it never states when to use this versus codex_gravity_completion_status or codex_gravity_cancel_completion, nor what happens if a watch already exists without resume=true.

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 does real work on failure semantics: it blocks until a completed reply, returns status=unconfirmed when nothing is observable, and never guesses or resends. It omits other behavioral facts an agent needs — that this posts a real, non-retractable message into a live desktop chat, that the desktop app must be running and focused, and that the call blocks up to the timeout window.

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, front-loaded with the action and followed by the failure contract. No preamble and no wasted clauses.

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

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

An output schema exists, so return-shape explanation is rightly omitted, and the unconfirmed status is covered. However, with 4 parameters at 0% schema coverage and no annotations, the description leaves the two timing parameters and the blocking duration undefined — a meaningful gap for a call that can hold for up to 300 seconds 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 coverage is 0%, so the description must carry all parameter meaning, and it only obliquely hints at thread_id ("exact existing ... chat") and message ("one message"). poll_seconds and timeout_seconds are completely undocumented anywhere, despite governing the blocking behavior described in the text.

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 definition pairs a specific verb ("Send one message") with a specific resource ("exact existing ChatGPT/Codex desktop chat") and adds the blocking-wait semantic, so the action is unambiguous. It does not name or contrast with nearby siblings such as antigravity_gui_followup or codex_gui_status, so differentiation is left implicit.

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?

"Exact existing ... chat" implies a thread must already exist, which is the main usage precondition, but the description never states when to choose this over codex_gui_status, antigravity_gui_followup, or team_send_message. No explicit when-not or alternative routing is given.

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

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

With no annotations, the description carries the full burden and does disclose two substantive traits: the operation is read-only (no side effects) and it only works from inside the Codex desktop app. It stops short of describing failure behavior when run outside that environment, but the core behavioral profile is covered.

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 sentence plus a short qualifier clause, front-loaded with the capability and followed by the safety/environment constraint. 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?

An output schema exists, so return values need not be spelled out, yet the description usefully previews the payload shape and the environment prerequisite. The remaining hole is the undocumented required thread_id argument.

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 required parameter thread_id has 0% schema description coverage and is never mentioned in the description. An agent has to guess whether it is a chat thread identifier, a session id, or something else, and where to obtain it.

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

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

States a specific verb (Inspect) and resource (ChatGPT/Codex desktop app) and enumerates what is surfaced: app-tools catalogue, busy state, turn count, last message. That distinguishes it from codex_gui_ask, though the description never names that sibling explicitly.

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

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

'Read-only; requires running inside the Codex desktop app' gives a real precondition, and 'Inspect' implies a status-check role. However, it never says when to prefer this over codex_gui_ask or antigravity_gui_status, leaving the choice 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?

No annotations are supplied, so the description carries the disclosure burden. It does characterize the operation as a read-only enumeration plus a live reachability probe, which is useful behavioral context, but it says nothing about how reachability is determined, latency/caching, or whether the call has side effects on the transports.

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 that enumerates the exact items returned and the liveness attribute, with no filler. Nothing is wasted.

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

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

An output schema exists, so return-shape explanation is not required, and the description covers what is listed and the reachability flag. However, for a two-parameter tool with zero schema documentation, the total absence of parameter guidance leaves a real gap for an agent deciding how to invoke it.

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

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

Schema description coverage is 0% for both parameters: gui_agent (boolean, default false) and codex_thread (nullable string) appear with no descriptions in either schema or description. The description never mentions these parameters, so an agent cannot tell whether gui_agent restricts the listing to GUI transports or how codex_thread scopes results.

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 ("List") plus a precisely enumerated resource (team agent transports: codex CLI, codex-gui, antigravity, antigravity-gui) and the reachability check it performs. It is clearly distinguishable from mutation/messaging siblings like team_send_message or team_run_task, though it never names the status siblings (codex_gui_status, antigravity_gui_status) to draw the line 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?

The phrase "whether each is reachable right now" implies a pre-flight discovery use case, but no explicit when-to-use, when-not-to-use, or alternative is given. An agent must infer that this is the tool to call before dispatching to a transport.

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 does the important work itself: it discloses that cancellation is a request, that in-flight agent turns are allowed to finish, and that no new round starts. That is genuinely useful non-obvious semantics for a mutation tool. It omits idempotency and behavior when the session is not running, which keeps 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?

Two short sentences with the scoping constraint and the key behavioral caveat front-loaded. Nothing is wasted and nothing is buried.

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

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

An output schema exists, so return values need not be described, and the async-cancellation semantics are covered. But for a cancellation operation with zero annotation coverage and fully undocumented parameters, the definition leaves real gaps: what happens on an unknown/already-finished session, and whether the call is idempotent.

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

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

Schema description coverage is 0% for both required parameters, so the description must compensate and does not — neither session_id nor workspace_path is mentioned or explained. The agent gets no guidance on ID format or whether the path must match the session's origin.

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 ('Request cancellation of a team session') and scopes it to 'running in this MCP process', which separates it from the launch/report siblings like team_run_task and team_report. It does not name a sibling as an explicit alternative, so it falls short of a 5.

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

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

The phrase 'running in this MCP process' implies the precondition (there must be a live session) but the description never says when to call this versus alternatives such as letting the session end naturally, nor what to do if the session is already stopped. Usage is implied rather than stated.

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

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

No annotations are provided, so the description carries the full burden. It does disclose the default comparison behavior and the dimensions examined, but never states that this is a read-only operation, whether it needs specific permissions, or any rate/cost characteristics. Return values are covered by the output schema, so the remaining gap is the safety/operational profile.

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

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

Two tight sentences with no waste, and the core purpose plus the default behavior are front-loaded. Efficient and 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?

The output schema covers return values and the description covers purpose and default, but with 0% parameter coverage and no annotations, the mapping of session_id/against/workspace_path is left unexplained. Adequate for the goal but incomplete for correct invocation.

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

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

Schema coverage is 0%, so the description must explain the three parameters. It implies two session identifiers ('compare two team sessions', 'defaults to the two most recent'), but never distinguishes what session_id vs against mean or that workspace_path is required, leaving the actual parameter semantics to inference.

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 (compare) and resource (two team sessions), then enumerates exactly what is compared: status change, resolved/new blockers, approvals, and proposal diff. That is well beyond tautology and clearly distinct from siblings like team_status or team_transcript, though it doesn't name those alternatives 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?

The description gives a useful default ('the two most recent sessions'), implying usage without providing the compared sessions. However, it never says when to use this over team_transcript or team_status, nor any prerequisites, so guidance is implied rather than explicit.

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

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

No annotations are provided, so the description carries the burden; 'Read' implies a non-mutating operation, which is helpful. However, it does not disclose behavior when the decisions file is missing, whether the log is truncated, or how ordering/recency works, leaving meaningful behavioral gaps for a tool with zero annotation coverage.

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 core resource is named first and the purpose follows immediately.

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

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

An output schema exists, so return values need not be described, and the description establishes the source and purpose. But for a two-parameter tool with 0% schema coverage, the absence of any explanation of limit or of missing-file behavior leaves it only minimally 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?

Schema description coverage is 0% for both parameters, and the description never mentions workspace_path or limit. The relative path hint implies workspace_path scopes the lookup, but limit (default 8) is completely unexplained — it presumably caps how many decisions are returned, but the agent must 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 (Read) and resource (the project decision log at .codex-gravity/decisions.md), plus what it contains (accepted decisions given to later sessions). It is clearly distinguishable from siblings like team_transcript or team_status, though it does not explicitly name an 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?

The phrase 'the accepted decisions later sessions are given as context' implies when the tool is useful (loading prior project context), but there is no explicit when-to-use/when-not guidance or named alternative among the many team_* and codex_* siblings.

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 does carry the burden, and it usefully discloses that the output is one self-contained HTML file and that the call returns a written path. However, it omits that this writes a file to disk, where that file lands, whether it overwrites anything, or any permission requirements.

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

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

Two tight sentences with no filler; the artifact description is front-loaded and the return value follows. Every clause earns its place.

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

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

An output schema exists, so the return contract needn't be spelled out, and the description still names the return value. But with no annotations and zero parameter documentation, an agent still can't tell what session_id defaults to or what limit bounds — meaningful gaps for a three-parameter tool.

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

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

Schema description coverage is 0%, so all three parameters rely purely on their names. The description says nothing about session_id (which session is selected or what happens when empty), limit (500 of what — transcript entries?), or workspace_path, so it fails to compensate for the documented 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 pairs a specific verb ('Render') with a concrete resource ('team session or diff review') and enumerates the artifact's contents (verdict, blockers, verification output, transcript). It is clearly a different output shape from siblings like team_transcript or team_status, but it never names those alternatives 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?

'Render a team session (or diff review)' implies the situation in which to use this tool, but there is no explicit when-to-use, when-not-to-use, or comparison to team_transcript/team_decisions. The agent must infer that this is the export/report step after a session exists.

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 burden, and it does add real value: it discloses that an optional real verification command may execute, and that outcomes include unavailable, deadlocked and failed states honestly. However, it says nothing about runtime duration, cost of a multi-round loop, filesystem writes to workspace_path, or credential/desktop-app requirements that matter for a default 3-round adversarial pipeline.

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 dense sentences with the capability statement front-loaded, followed by the transport variant and the failure-reporting guarantee. Nothing is padding, though the phase list is a compressed run-on that must be parsed carefully.

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 output schema relieves the description of explaining return values, and the honest-failure note is valuable. But for a 16-parameter orchestration tool with no annotations and no parameter documentation, an agent still cannot confidently set review_with/judge_with/veto_agents or predict what the run will do to its workspace.

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 16 parameters, so the schema labels alone (plan_with, judge_with, veto_agents, reviewer_weights) give no meaning. The description explains only codex_thread, leaving 15 parameters undocumented, including consequential ones like require_unanimous, max_rounds and verification_retries whose defaults silently change 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?

The definition names a specific verb ('Run') and resource ('two-way Codex+Antigravity team') and enumerates the phases (plan, review, cross-examination, consensus, verification), so an agent knows this is a multi-agent orchestration pass rather than a single call. It never explicitly contrasts itself with siblings like team_compare or team_send_message, which keeps it from 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?

The only routing guidance is 'Pass codex_thread to use the ChatGPT/Codex desktop app instead of the CLI,' which selects between transport modes inside this tool rather than against a sibling. There is no statement of when to prefer this tool over the many adjacent team_* tools, so usage is implied rather than prescribed.

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 burden, and it does disclose one genuinely non-obvious trait: delivery is live only when the session runs in this process, otherwise the message is merely persisted for audit. It says nothing about failure modes (unknown session_id, invalid workspace_path), whether the send is blocking, or whether a persisted-but-undelivered message can be recovered.

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, and the core action is front-loaded before the delivery caveat. Every clause carries information not available in the schema or structured fields.

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 output schema covers return shape, so the description needn't explain responses. But for a 6-parameter write tool with no annotations and 0% schema coverage, it is under-specified: nothing describes required session/workspace semantics, routing via `recipient`, or what happens on an invalid target.

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 6 parameters, so the description must compensate. It does valuable work for two of them — enumerating valid `kind` values (the schema declares no enum) and framing `sender` as 'human' or another agent — but leaves `workspace_path`, `session_id`, `recipient` defaults, and body expectations entirely to the field names.

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

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

The description gives a concrete verb+resource ("Send a message into a team session") and even names the identity model and message kinds, so the action is unmistakable. It does not, however, position itself against near-neighbours that could plausibly be confused with it (team_report, team_decisions, team_transcript), leaving that differentiation to the reader.

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

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

Usage is only implied: the enumerated kinds (question, answer, critique, approval, rejection) hint at when each message form applies, and "as 'human' or another agent" implies the caller-identity context. There is no explicit statement of when to use this tool versus team_transcript, team_report, or team_run_task, and no 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 must carry behavior itself. It does add one genuinely useful trait — it will not reconstruct a missing session, so an agent knows to expect a failure rather than synthesized state. It never states that it is read-only/non-mutating, what error surfaces for an unknown session_id, or whether the action is rate-limited.

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

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

Two tight sentences with no filler; the return-field list is front-loaded so the agent learns the payload shape immediately. The trailing clause is slightly oblique but earns its place as the only behavioral constraint given.

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?

An output schema exists, so the return values need no further explanation, and the two parameters are fairly self-explanatory by name. However, for a session-scoped read tool with no annotations and zero schema coverage, the description leaves the lookup semantics and failure behavior underspecified.

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?

Both parameters have 0% description coverage in the schema and the description mentions neither session_id nor workspace_path. It is unclear whether workspace_path scopes lookup across workspaces or identifies where the transcript path is rooted, which matters for constructing correct calls.

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 ('team session') and enumerates what comes back: running/finished state, last message, decision, transcript path. It does not explicitly differentiate itself from close siblings like team_transcript or team_decisions, so it falls just short of a 5.

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

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

There is no statement of when to call this versus team_transcript, team_report, team_decisions or team_agents. 'Never reconstructs a missing session' hints at the precondition (session must already exist) but never says so directly or routes the agent anywhere else.

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 not state that this is read-only, whether it paginates, how 'limit' truncates output, or what happens when session_id is unknown. It discloses only the output serialization choice, leaving the operational profile largely undocumented.

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

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

A single well-formed sentence with the resource and the output-format choice front-loaded; nothing is wasted. It is arguably too terse given the four undocumented parameters, but the sentence itself is 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?

An output schema exists, so return values needn't be explained, but for a 4-parameter tool with zero schema coverage and no annotations the description should at minimum explain limit/pagination and session identity. As written, an agent cannot predict transcript size or scoping behavior.

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 only clarifies 'fmt' (JSON messages vs rendered Markdown). The meaning of workspace_path, session_id, and especially limit (200 default — per-page? max messages? truncation point?) is 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?

States a specific verb and resource ('Read a team session transcript') plus the two output forms (JSON messages or rendered Markdown), which separates it from siblings like team_report and team_decisions that aggregate rather than dump raw sessions. It doesn't explicitly name which sibling to prefer for summary-style needs, so it stops short of a 5.

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

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

There is no guidance on when to call this versus team_report, team_decisions, team_compare, or team_status, all of which operate on team session data. The agent must infer from the name alone that this is the raw-transcript option.

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