Diogenes Gemini Suite & Agents MCP

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

Beyond the annotations (readOnly, non-destructive, idempotent), the description discloses statelessness, a 32 KB payload ceiling, a 60 RPM rate limit, the '?demo=true' and L402 (100 sats) access paths, and the HTTP 400 failure mode. Those are exactly the operational facts an agent needs and none are in the structured fields.

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

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

Front-loaded with purpose and the sibling routing rule, then the operational constraints. It is dense and slightly runs-on in the final parenthetical clause, but every sentence carries information that is not duplicated 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 an output schema, the return values need no explanation. Combined with the auth/payment path, rate and size limits, and error behavior, nothing material is missing 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 100% and the enum is documented in-schema, so the baseline is 3. The description only restates the 'modality_focus' default and the nature of 'input' without adding format or syntax guidance beyond the schema.

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

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

States a specific verb (analyzes) plus the exact resource (combined multimodal prompts spanning text, image descriptors, audio transcripts, and video temporal events) and names the underlying model. It also distinguishes itself from the sibling generate_gemini_completion, so an agent can route 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?

Explicit when-to-use ('correlating information across multiple media modalities in a single reasoning pass') and an explicit when-not with the named alternative ('for running pure text-only reasoning or coding prompts, use generate_gemini_completion instead'). 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?

Annotations already cover readOnly/idempotent/openWorld/non-destructive, yet the description adds genuinely new operational facts: stateless edge call, 32 KB response cap, 60 RPM limit, 300 sats MPP pricing, '?demo=true' bypass, and HTTP 400 on invalid input. That is exactly the beyond-annotation context the dimension rewards.

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

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

Two tightly packed sentences that front-load purpose, then routing, then operational limits. Nothing is truly wasted, but the run-on density (pricing, rate limit, size cap, error code in one breath) makes it slightly harder to scan than necessary.

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 description still covers cost, limits, error behavior and the alternative tool. The one material gap is the mismatched parameter naming and default value, which leaves an agent unsure whether to send 'query' or 'research_topic' and what default applies.

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 would be 3, but the description introduces conflicting facts: it says 'output_density' defaults to 'concise_5_points' while the schema says 'executive_10_points', and it presents 'research_topic' as an accepted input while the schema's required field is 'query'. Those mismatches actively mislead rather than add meaning.

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

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

A specific verb ("Compiles") plus a well-defined resource ("structured JSON research dossier") with the returned fields named inline ('key_findings', 'synthesis_quality_score', 'sources_cited'). It also names the sibling it is not (conduct_deep_research_investigation for L402 narrative reports), so an agent can separate 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?

Explicit when-to-use ("generating a strict-JSON cited intelligence brief paid via Base USDC MPP session headers") paired with an explicit alternative and the condition selecting it (L402 long-form narrative → conduct_deep_research_investigation). Payment mode and demo-mode fallback are also stated, leaving little 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?

Beyond standard hints, the description provides critical operational behavior not found in schema or annotations, such as the stateless nature, specific size/rate limits (max 32 KB, 60 RPM), and defined error behavior (returns HTTP 400 if invalid).

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 dense and front-loaded, packing both functional and operational data into one paragraph. While highly effective, the sheer volume of technical jargon (KB, RPM, Lyria 3) prevents a perfect 5, though the information is logically ordered.

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 complexity of the tool (music generation, specific edge constraints, and failure modes), the description is exhaustively complete, leaving no critical question unanswered for an agent attempting to use it correctly.

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

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

With schema coverage at 100%, the description meets the baseline for supplemental documentation. It successfully reinforces the default value for the `genre_preset` parameter but does not add semantic value that wasn't already structured.

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 is highly specific, naming the output (musical tracks, ambient loops), the mechanism (Google Lyria 3), and the inputs it transforms (genre, tempo, mood prompts). It clearly defines what the tool's specific domain is.

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 tool provides explicit 'when to use' scenarios (musical scores, audio loops) and a direct 'when not to use' instruction by pointing to `synthesize_gemini_speech_audio` as the alternative for TTS tasks.

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?

Goes well beyond the annotations by disclosing statelessness, a 32 KB payload cap, 60 RPM throttling, '?demo=true' access, an L402 payment requirement (300 sats), and the HTTP 400 failure mode. Annotations already cover readOnly/openWorld/idempotent, so this coverage is strong; the one blemish is that the stated 'depth_tier' default conflicts with the schema, which sows doubt about the stated mechanics.

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?

Core purpose and the sibling alternative are front-loaded, and each clause carries distinct information. The final sentence is dense — API mechanics, payment, and error semantics compressed into one line — but it is not padded.

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

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

Given an output schema exists, return values needn't be described; the description instead covers operational constraints (size, rate limit, payment, error code) that the structured fields do not. Aside from the default-value discrepancy, an agent has everything needed to call this 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 coverage is 100%, so the baseline would be 3, but the description actively contradicts the schema: it says depth_tier 'defaults to quick_synthesis' while the schema says 'defaults to exhaustive_report when omitted.' For a caller choosing omission vs. explicit tier, this is a costly error rather than harmless redundancy, and no additional meaning is added for the 'input' 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?

States a specific verb and resource — an iterative multi-hop investigative research session via Gemini Deep Research Pro producing a cited technical report — and names the sibling (search_gemini_grounded_web) it is not. An agent can distinguish this from the other 13 siblings without opening any schema.

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

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

Explicitly scopes use to 'complex scientific, architectural, or market questions requiring deep multi-hop synthesis' and states the exclusion plus the alternative: fast single-turn fact lookup goes to search_gemini_grounded_web. When-to-use, when-not-to-use, and the fallback are all present.

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?

Beyond the annotations (which already declare readOnly/idempotent/openWorld/non-destructive), it discloses that the call is stateless, capped at 32 KB, rate-limited to 60 RPM, has a 150 s timeout, and supports demo/L402 payment modes. It also states the failure behavior (HTTP 400 on invalid input), which is exactly the kind of operational context the description should carry.

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

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

Three sentences, front-loaded with purpose then routing then operational constraints; almost every clause carries information. It is dense to the point of being slightly packed (payment, size, rate, timeout, error code in one sentence), but nothing is clearly wasteful.

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

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

An output schema exists so return values need not be described; the description covers the missing pieces an agent needs — auth/payment path, size and rate limits, timeout, and error behavior. Nothing required to invoke 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 description coverage is 100%, so both parameters are already documented. The description only restates the 'input' role and the execution_mode default, adding no new syntax or format guidance beyond the schema — the baseline of 3 for schema-complete tools applies.

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

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

States a specific verb ('Dispatches') and resource ('Google's Antigravity autonomous agent') with the scope of what the agent does (multi-step planning, tool orchestration, verified execution). It explicitly names the sibling it is not (conduct_deep_research_investigation), so an agent can route 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 a positive trigger ('multi-stage software engineering or workflow tasks that require autonomous planning') and a negative rule with the alternative tool named for research dossiers. The routing decision is fully specified rather than 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?

Annotations already declare readOnly/idempotent/non-destructive, but the description adds context annotations cannot: stateless edge call, 32 KB payload ceiling, 60 RPM throttle, demo-mode or L402 payment (50 sats), and an HTTP 400 on invalid input. These are operational traits an agent needs before calling.

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 dense sentences, front-loaded with the core action and the alternative, then limits/auth/response codes. Every clause carries information, though the parenthetical model list and marketing tone ('zero Google account') add a little padding.

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, and the description covers limits, rate, auth/payment, defaults, and error behavior. The residual gap is the demo/L402 flags, which are mentioned but are not schema parameters, leaving it unclear how an agent is meant to pass them.

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 baseline is 3, but the description adds real meaning: the 'model' default is 'gemini-4-argon' and the prompt has a 32 KB cap. The added value is undercut by saying 'all 45 models' while the enum exposes only four, which could confuse an agent reasoning about valid model 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?

Specific verb + resource ("generates text completions and structured reasoning") with the exact model family named, and it explicitly distinguishes itself from execute_antigravity_agent. An agent can tell what this does and what it does not do without opening the schema, though the '45 models' claim versus the 4-value enum is a small inconsistency.

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

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

States the use case (single-turn reasoning, coding, analytical prompts on a specific Gemini model) and names the alternative with the selecting condition: multi-step tasks needing remote tool execution go to execute_antigravity_agent. That is explicit when/when-not 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?

Goes well past the annotations by disclosing statelessness, the 32 KB input cap, 60 RPM rate limit, L402 Lightning payment (10 sats) and a demo mode, plus a 400 error on invalid input. One weak spot: the description advertises 'configurable Matryoshka dimensions' but the schema exposes no dimension parameter, leaving ambiguity about how 3,072 vs 768 is actually selected.

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

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

Three sentences, front-loaded with the core purpose and the sibling exclusion before the operational details. Some sentences are heavily clause-stacked (payment, limits, error code in one breath), which slightly hurts scanability but not comprehension.

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, read-only embedding call with an output schema and full annotation coverage, everything an agent needs to call it correctly is present: input limit, auth/payment path, rate limit, model default, and failure mode. Return-value details are correctly left to the 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?

Schema coverage is 100%, so baseline is 3; the description still adds value by restating the default model and framing 'text' as passage, code snippet, or query. It adds little beyond the schema for 'model' (the enum and default are already documented), so it lands just above baseline rather than at 5.

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 (generates), resource (normalized semantic vector embeddings), producer (Gemini Embedding 2), and dimensionality (3,072-D / 768-D), plus the downstream use (RAG indexing, cosine search). It also explicitly names the sibling it is not (search_gemini_grounded_web), so an agent can separate it from the other Gemini tools without opening a 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 says 'Use when embedding text passages or queries' and gives an exclusion rule with the named alternative for grounded factual queries. The when/when-not pair is unambiguous and immediately actionable.

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?

Goes well beyond the annotations by disclosing statelessness, a 32 KB payload cap, 60 RPM rate limiting, the ?demo=true switch and L402 payment of 75 sats, and that invalid input returns HTTP 400. These are operational facts an agent cannot get from readOnlyHint/idempotentHint, and they are consistent with the annotations.

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-loads purpose and the sibling exclusion in the first two sentences, which is ideal. The final sentence crams rate limits, payload cap, demo mode, payment, and error behavior into a single dense parenthetical, which is efficient but reads as a run-on rather than a cleanly separated operational note.

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 generation tool with an output schema present, the description covers everything an agent needs: cost/payment, rate limits, input cap, and failure mode. The only gap is the incorrect aspect_ratio default, which leaves the agent with conflicting guidance on that parameter.

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 would be 3, but the description contradicts the schema by claiming aspect_ratio 'defaults to 1:1' while the schema says it 'defaults to 16:9 when omitted.' That conflicting default is actively misleading for the one optional parameter and is worse than saying nothing.

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 (generates) plus concrete outputs (photorealistic illustrations, UI mockups, technical diagrams) from text prompts, and names the model family. It explicitly distinguishes itself from generate_veo_cinematic_video, so an agent can route between static-image and video generation 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 an explicit when-to-use clause ('creating static visual assets, icons, or architecture diagrams from text descriptions') and an explicit when-not-to-use clause that names the alternative sibling for animated clips. 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?

Annotations already declare readOnly/idempotent/non-destructive, and the description adds genuinely new operational context: stateless edge call, 32 KB payload cap, 60 RPM rate limit, auth via '?demo=true' or L402 payment of 650 sats, and a 400 error on invalid input. That is exactly the kind of cost/limit/auth information an agent cannot get from the structured fields.

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 core capability is front-loaded, followed by the sibling routing and then operational constraints. It is dense but nearly every clause carries new information; only the payoff/auth details are crammed into a single parenthetical that is harder to parse than it needs to be.

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 an output schema present, return values need not be explained, and the description covers auth, limits, and failure behavior. What remains unstated is whether generation is synchronous or returns a job handle, and typical latency/cost per call beyond the L402 price — useful given video generation is long-running.

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 parameters are already documented, and the description reinforces 'prompt' as a scene description. However, it claims 'motion_style' defaults to 'static_tripod', directly contradicting the schema's stated default of 'smooth_tracking_shot' — this actively misleads an agent picking an omitted-value 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?

States a specific verb and resource ('Synthesizes high-definition cinematic video sequences') with qualifying traits (temporally coherent camera motion and physics) plus the underlying model. It explicitly distinguishes itself from the sibling image generator, so an agent can choose between them 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 concrete use cases (moving clips, product B-roll, animated scene renders from text prompts) and names the alternative for the adjacent case ('for rendering static single-frame images or diagrams at lower cost, use generate_nano_banana_image instead'). The selection condition is explicit rather than 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?

Adds substantial context beyond the annotations: stateless edge call, 32 KB payload cap, 60 RPM rate limit, '?demo=true' trial path, L402 payment of 200 sats, and HTTP 400 on invalid input. It also explicitly reconciles the 'executes actions' framing with readOnlyHint=true by labeling itself a stateless read-only edge call, though it does not clarify whether side effects persist on the target UI.

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?

Purpose and sibling routing are front-loaded in the first two sentences, with operational constraints compressed into a final clause. Dense but nearly every clause carries information; the long parenthetical action list and the auth/payment clause make the last sentence feel packed.

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 an output schema present and rich annotations, the description only needed to add scope, routing, and operational limits — all of which it does. The remaining gap is what a caller should expect from the returned plan/action sequence and whether GUI actions are simulated versus applied.

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 parameters are already documented, and the enum for viewport_preset is self-explanatory. The description adds the default preset value (already in the schema) and mentions the demo/L402 query flag, which is not an input property, so marginal value over structured fields.

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

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

The first sentence names a specific verb (plans and executes) and enumerates the concrete resources/actions (OS-level desktop, browser DOM, GUI coordinates: click, type, scroll, wait) plus the underlying engine. It is immediately distinguishable from execute_antigravity_agent and other 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?

Explicit routing guidance: 'Use when automating interactive web UIs or desktop workflows that lack a direct REST API' and 'for running code-first API and terminal automation tasks, use execute_antigravity_agent instead.' Both the selection condition and the exclusion/alternative 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?

Annotations already cover readOnly/idempotent/non-destructive, but the description goes well beyond them: statelessness, a 32 KB payload ceiling, a 60 RPM rate limit, demo-access via '?demo=true' or L402 payment of 150 sats, and an HTTP 400 failure mode for invalid input. These are operational facts an agent cannot obtain from the annotations and that directly affect retry and batching 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?

Purpose and the sibling exclusion are front-loaded, which is the right ordering. The final sentence is information-dense to the point of being a run-on, packing payload cap, rate limit, payment, and error semantics together, but nearly every clause carries operational value an agent needs.

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 description is not obliged to explain return values. Combined with the annotations covering the safety profile and the description covering limits, access modes, and error behavior, an agent has everything required to invoke this correctly and handle failures.

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 both parameters are already fully documented, including the coordinate_frame enum and its default. The description only restates the default value ('coordinate_frame' defaults to 'cartesian_xyz_meters') without adding syntax, format, or content guidance for the prompt body beyond what the schema says. Baseline 3 applies.

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

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

States a specific verb ('Computes') with three concrete output artifacts (3D spatial affordances, obstacle-avoidance waypoints, manipulator grasp sequences) and names the reasoning engine. It also draws a hard boundary against operate_computer_use_agent, so an agent can distinguish it from siblings without opening a 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 enumerates the use cases ('physical robot arm kinematics, mobile navigation waypoints, or spatial scene task orders') and names the correct alternative for the adjacent-but-different case ('2D desktop or browser GUI screens, use operate_computer_use_agent instead'). Both when-to-use and when-not-to-use 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?

Annotations already declare read-only/idempotent/non-destructive, but the description goes well beyond them: size cap (32 KB), rate limit (60 RPM), statelessness, demo mode, L402 payment of 75 sats, and HTTP 400 on invalid input. That is exactly the operational context an agent needs before calling.

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 core purpose and the sibling routing are front-loaded in the first two sentences. The final sentence is a dense run-on packing budget, rate limit, defaults, demo/L402 and error behavior, which is efficient but slightly overloaded for one clause chain.

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, and the description still covers scope, selection criteria, limits, auth/payment, and error behavior. Nothing material for correct invocation is missing.

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

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

Schema description coverage is 100%, so both parameters and the enum are already documented. The description restates 'input' and the response_tone default without adding format or syntax guidance beyond the schema, so baseline 3 applies.

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

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

States a specific verb and resource ('Processes real-time conversational dialog turns') plus the differentiating capabilities (acoustic emotion, interruption handling, paralinguistic cues). It explicitly names the sibling synthesize_gemini_speech_audio and the boundary between them, so an agent can route correctly 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 an explicit when-to-use ('interactive voice-agent dialog turns that require tone and turn-taking awareness') and a when-not-to-use with the alternative and its condition ('one-way text-to-speech readout of a static text string → synthesize_gemini_speech_audio'). 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?

Annotations already declare readOnly/idempotent/non-destructive, yet the description adds material facts beyond them: stateless edge call, 32 KB payload cap, 60 RPM rate limit, L402 payment of 75 sats, demo-mode escape hatch, and HTTP 400 on invalid input. The only shortfall is that the 400/invalid condition is left unspecified as to what 'invalid' means, but operational constraints are otherwise well disclosed.

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 capability and the sibling disambiguation are front-loaded, which is the right ordering. The final sentence is a run-on that crams rate limits, payment, demo mode, and error behavior into one clause, but every fact still 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 not be described; the description instead covers cost, rate limits, statelessness, and failure behavior — exactly the gaps the schema and annotations leave. Nothing an agent needs before calling it is missing.

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

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

Schema coverage is 100% and both parameters carry enum/default documentation, so the schema already does the heavy lifting. The description restates the 'distance_units' default and names the 'prompt' parameter but adds no format, syntax, or example guidance beyond that, which is the expected baseline-3 level.

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 ('Executes geospatial and point-of-interest queries') and enumerates the resource outputs (addresses, coordinates, hours, spatial context). It explicitly distinguishes itself from the sibling workflow tool search_gemini_grounded_web, so an agent can route without inspecting 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 positive triggers (resolving physical locations, venues, transit distances, regional infrastructure) and names the exact alternative with its condition ('for searching general web articles, documentation, and news, use search_gemini_grounded_web instead'). This is explicit when/when-not 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?

Annotations only cover safety/idempotency, and the description goes well beyond them: statelessness, 32 KB payload cap, 60 RPM throttle, L402 pricing (75 sats) with a ?demo=true bypass, and HTTP 400 on invalid input. It loses a point because it asserts recency_bias 'defaults to past_24h', which conflicts with the schema and could mislead; the low-latency claim is also unquantified.

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

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

Front-loaded with purpose, then usage, then constraints - a sensible ordering with no filler sentences. The final sentence is an overloaded run-on packing limits, auth, defaults, and error codes into one clause chain, which slightly hurts scanability.

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-param tool with a full output schema, this covers the operational essentials an agent needs: cost model, rate/payload ceilings, auth options, and failure mode. The only meaningful gap is the incorrect default it reports for the optional enum parameter.

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 baseline would be 3 and the schema already documents both parameters. The description's only added parameter claim is that recency_bias defaults to 'past_24h', which directly contradicts the schema's 'any_time' - misleading guidance is worse than silence.

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 ('Answers factual queries with live Google Search grounding') plus the concrete payload (sourced answers + grounding metadata). The final clause explicitly names the sibling it replaces for geo queries, so an agent can discriminate 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?

'Use when verifying live web facts, documentation updates, or current events' gives positive selection criteria, and 'for querying geographic places, coordinates, directions, and local business data... use search_gemini_grounded_maps instead' names the alternative and the condition that routes to it.

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

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

Annotations already declare readOnly/idempotent/non-destructive/non-open-world, and the description adds substantial context beyond them: statelessness, a 32 KB input cap, a 60 RPM rate limit, the ?demo=true or L402 (50 sats) access path, and HTTP 400 on invalid input. It does not contradict the annotations, since synthesis is a deterministic, side-effect-free read-like call.

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, purpose front-loaded, with the exclusion clause placed after the primary use case. The parenthetical stack in the second sentence (size, rate, payment, error code) is dense but each clause carries operational information, so little 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 values need not be explained; what remains — access/payment path, size and rate limits, error behavior, default persona, and the sibling alternative — is all covered. An agent has everything needed to invoke this correctly on the first try.

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 a real constraint not stated in the schema by tying the 32 KB cap to the 'text' payload and noting the default persona. It does not explain the semantic differences between the four enum personas, which keeps it below a 5.

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 ('Converts written text into natural, prosody-controlled spoken voice audio') plus the underlying engine, which pins down the capability precisely. It also explicitly names the sibling it is not (process_live_audio_dialogue) and the use case that separates them.

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

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

Gives an explicit when-to-use ('rendering voiceover narration or spoken agent replies from a deterministic text script') and routes the alternative case ('bidirectional conversational audio dialog') to process_live_audio_dialogue. No inference is required to choose between the two.

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