This server offers account-less Google Gemini AI capabilities: text inference, autonomous agents, deep research, media generation, grounded search/maps, and embeddings.
Generate text and structured reasoning across all 45 Gemini models with configurable thinking budgets.
Execute multi-step autonomous agent tasks, code synthesis, and tool orchestration.
Synthesize cited multi-hop technical and market research dossiers.
Generate high-resolution images, diagrams, and UI assets.
Create cinematic video clips or studio audio tracks.
Run real-time Google Search and Google Maps grounded reasoning with source URLs.
Generate 3072-dimensional semantic embeddings for RAG and agent memory.
Provides real-time Google Search grounded reasoning, returning structured JSON with source URLs for up-to-date web information.
Provides account-less access to all 45 Google Gemini models (e.g., Gemini 4 Argon, Gemini 3.1 Pro, Gemini 3.8 Flash) and autonomous agents (Antigravity Agent, Deep Research Pro, Nano Banana Pro, Veo 3, Lyria 3) for text generation, multi-step reasoning, code synthesis, deep research, image/video/audio generation, and vector embeddings.
Enables real-time Google Maps grounded reasoning, returning structured JSON with source URLs for location-based queries and geospatial data.
Click on "Deploy Server".
Wait a few minutes for the server to deploy. Once ready, it will show a "Started" state.
In the chat, type @ followed by the MCP server name and your instructions, e.g., "@Diogenes Gemini Suite & Autonomous Agents MCP Research the latest AI chip market trends and cite reliable sources"
That's it! The server will respond to your query, and you can continue using it as needed.
Here is a step-by-step guide with screenshots.
diogenes-gemini-suite-mcp)
Diogenes Gemini Suite & Autonomous Agents MCP is a focused, zero-bloat Model Context Protocol (streamable-http) package powered by the Diogenes Autonomous Microservice Gateway.
Instead of loading all 85 gateway endpoints into your LLM's context window, installing this package exposes only the 15 specialized gemini-suite tools needed for AI & LLM Integration:
15 TDQS 5.0/5.0 MCP tools providing account-less access to all 45 Google Gemini models (Gemini 4 Argon, 3.1 Pro, 3.8 Flash) and autonomous agents (Antigravity Agent, Deep Research Pro, Computer Use, Nano Banana Pro, Veo 3, Lyria 3) via L402, x402, and MPP.
mcp.json) for Cursor, Claude Desktop & WindsurfNo API keys, user accounts, or local dependencies required. Add this scoped endpoint to .cursor/mcp.json or claude_desktop_config.json:
{
"mcpServers": {
"diogenes-gemini-suite": {
"transport": "streamable-http",
"url": "https://diogenes-micro-gateway.corinth.workers.dev/mcp/gemini-suite"
}
}
}Related MCP server: NotebookLM MCP Server (Security Hardened)
gemini-suite (15 Tools)MCP Tool Name | Underlying REST Route | Settlement | Capability |
|
| 250 sats (L402) | Generates text completions and structured reasoning across all 45 Google Gemini foundation models (Gemini 4 Argon, 3.1 Pro, 3.8 Flash) with zero Google account or API key required. Use when running single-turn reasoning, coding, or analytical prompts on a specific Gemini model; for delegating multi-step autonomous tasks that require remote tool execution, use execute_antigravity_agent instead. Stateless read-only edge call (max 32 KB, 60 RPM): accepts 'prompt' ('model' defaults to 'gemini-4-argon'), supports '?demo=true' or L402 (250 sats), and returns HTTP 400 if invalid. |
|
| 500 sats (L402) | Dispatches a complex engineering or operational task to Google's Antigravity autonomous agent for multi-step planning, tool orchestration, and verified execution. Use when solving multi-stage software engineering or workflow tasks that require autonomous planning; for compiling exhaustive multi-source literature and market research dossiers, use conduct_deep_research_investigation instead. Stateless read-only edge call (max 32 KB, 60 RPM): accepts 'input' ('execution_mode' defaults to 'autonomous_verified'), supports '?demo=true' or L402 (500 sats), and returns HTTP 400 if invalid. |
|
| 1000 sats (L402) | Runs an iterative, multi-hop investigative research session via Gemini Deep Research Pro, cross-examining primary sources to produce a cited technical report. Use when investigating complex scientific, architectural, or market questions requiring deep multi-hop synthesis; for running a fast single-turn Google Search grounded fact lookup, use search_gemini_grounded_web instead. Stateless read-only edge call (max 32 KB, 60 RPM): accepts 'input' ('depth_tier' defaults to 'quick_synthesis'), supports '?demo=true' or L402 (1000 sats), and returns HTTP 400 if invalid. |
|
| 800 sats (L402) | Plans and executes OS-level desktop, browser DOM, and GUI coordinate actions (click, type, scroll, wait) using the Gemini Computer Use agent. Use when automating interactive web UIs or desktop workflows that lack a direct REST API; for running code-first API and terminal automation tasks, use execute_antigravity_agent instead. Stateless read-only edge call (max 32 KB, 60 RPM): accepts 'input' ('viewport_preset' defaults to 'desktop_1080p'), supports '?demo=true' or L402 (800 sats), and returns HTTP 400 if invalid. |
|
| 200 sats (L402) | Answers factual queries with live Google Search grounding, returning verified up-to-date answers accompanied by source URLs and grounding metadata. Use when verifying live web facts, documentation updates, or current events in a single low-latency call; for querying geographic places, coordinates, directions, and local business data via Google Maps grounding, use search_gemini_grounded_maps instead. Stateless read-only edge call (max 32 KB, 60 RPM): accepts 'prompt' ('recency_bias' defaults to 'past_24h'), supports '?demo=true' or L402 (200 sats), and returns HTTP 400 if invalid. |
|
| 250 sats (L402) | Executes geospatial and point-of-interest queries grounded in live Google Maps data, returning verified addresses, coordinates, operating hours, and spatial context. Use when resolving physical locations, venues, transit distances, or regional infrastructure data; for searching general web articles, documentation, and news, use search_gemini_grounded_web instead. Stateless read-only edge call (max 32 KB, 60 RPM): accepts 'prompt' ('distance_units' defaults to 'metric_km'), supports '?demo=true' or L402 (250 sats), and returns HTTP 400 if invalid. |
|
| 1000 sats (MPP) | Compiles a structured JSON research dossier ('key_findings', 'synthesis_quality_score', 'sources_cited') settled via Base EVM Machine Payments Protocol (MPP). Use when generating a strict-JSON cited intelligence brief paid via Base USDC MPP session headers; for running long-form narrative research reports via L402 Lightning, use conduct_deep_research_investigation instead. Stateless read-only edge call (max 32 KB, 60 RPM): accepts 'query' ('output_density' defaults to 'concise_5_points'), supports '?demo=true' or MPP (1000 sats), and returns HTTP 400 if invalid. |
|
| 50 sats (L402) | Generates normalized 3,072-dimensional or 768-dimensional semantic vector embeddings via Google Gemini Embedding 2 for RAG indexing and cosine-similarity search. Use when embedding text passages or queries via L402 Lightning with configurable Matryoshka dimensions; for running live Google Search grounded factual queries, use search_gemini_grounded_web instead. Stateless read-only edge call (max 32 KB, 60 RPM): accepts 'text' ('model' defaults to 'gemini-embedding-2'), supports '?demo=true' or L402 (50 sats), and returns HTTP 400 if invalid. |
|
| 300 sats (L402) | Analyzes combined multimodal prompts spanning text, image descriptors, audio transcripts, and video temporal events using Gemini Omni Flash. Use when correlating information across multiple media modalities in a single reasoning pass; for running pure text-only reasoning or coding prompts, use generate_gemini_completion instead. Stateless read-only edge call (max 32 KB, 60 RPM): accepts 'input' ('modality_focus' defaults to 'cross_modal_synthesis'), supports '?demo=true' or L402 (300 sats), and returns HTTP 400 if invalid. |
|
| 450 sats (L402) | Computes 3D spatial affordances, obstacle-avoidance waypoints, and manipulator grasp sequences using Gemini Robotics ER 2 embodied reasoning. Use when planning physical robot arm kinematics, mobile navigation waypoints, or spatial scene task orders; for interacting with 2D desktop or browser GUI screens, use operate_computer_use_agent instead. Stateless read-only edge call (max 32 KB, 60 RPM): accepts 'prompt' ('coordinate_frame' defaults to 'cartesian_xyz_meters'), supports '?demo=true' or L402 (450 sats), and returns HTTP 400 if invalid. |
|
| 350 sats (L402) | Generates photorealistic illustrations, UI mockups, and technical diagrams from text prompts using the Nano Banana Pro (Gemini 2.5 Flash Image) model family. Use when creating static visual assets, icons, or architecture diagrams from text descriptions; for synthesizing animated multi-second video clips with motion, use generate_veo_cinematic_video instead. Stateless read-only edge call (max 32 KB, 60 RPM): accepts 'prompt' ('aspect_ratio' defaults to '1:1'), supports '?demo=true' or L402 (350 sats), and returns HTTP 400 if invalid. |
|
| 1500 sats (L402) | Synthesizes high-definition cinematic video sequences with temporally coherent camera motion and physics using Google Veo 3. Use when generating moving video clips, product B-roll, or animated scene renders from text prompts; for rendering static single-frame images or diagrams at lower cost, use generate_nano_banana_image instead. Stateless read-only edge call (max 32 KB, 60 RPM): accepts 'prompt' ('motion_style' defaults to 'static_tripod'), supports '?demo=true' or L402 (1500 sats), and returns HTTP 400 if invalid. |
|
| 500 sats (L402) | Composes studio-grade instrumental music tracks, ambient loops, and multi-instrument arrangements from genre, tempo, and mood prompts using Google Lyria 3. Use when generating musical scores, soundtrack stems, or rhythmic audio loops; for converting written text into spoken human voice narration (TTS), use synthesize_gemini_speech_audio instead. Stateless read-only edge call (max 32 KB, 60 RPM): accepts 'prompt' ('genre_preset' defaults to 'cinematic_synth'), supports '?demo=true' or L402 (500 sats), and returns HTTP 400 if invalid. |
|
| 200 sats (L402) | Converts written text into natural, prosody-controlled spoken voice audio using Gemini 3.8 Flash Neural Text-to-Speech. Use when rendering voiceover narration or spoken agent replies from a deterministic text script; for conducting bidirectional conversational audio dialog comprehension, use process_live_audio_dialogue instead. Stateless read-only edge call (max 32 KB, 60 RPM): accepts 'text' ('voice_persona' defaults to 'neutral_broadcast'), supports '?demo=true' or L402 (200 sats), and returns HTTP 400 if invalid. |
|
| 300 sats (L402) | Processes real-time conversational dialog turns with native acoustic emotion, interruption handling, and paralinguistic cue comprehension via Gemini 3.8 Live. Use when handling interactive voice-agent dialog turns that require tone and turn-taking awareness; for performing one-way text-to-speech readout of a static text string, use synthesize_gemini_speech_audio instead. Stateless read-only edge call (max 32 KB, 60 RPM): accepts 'input' ('response_tone' defaults to 'direct_peer'), supports '?demo=true' or L402 (300 sats), and returns HTTP 400 if invalid. |
Free Account-Less Demo Mode: Append
?demo=trueto any REST endpoint above for an instant HTTP 200 schema preview at zero cost.
Install only the domain packages relevant to your workflow:
Package | Scoped MCP Endpoint | Spoke Repository |
1. Gemini Suite & Agents |
| |
2. Agent Guardrails & Sandbox |
| |
3. Web3, DeFi & 402 Security |
| |
4. EVE: Frontier Sui Move Suite |
| |
5. Context, Code & Solvers (15 Tools) |
| |
6. Dev, Data & Workflow Utilities (14 Tools) |
| |
7. Full Master Gateway (All 85 Services) |
|
Field | Value |
Category |
|
Transport |
|
Endpoint |
|
Manifest |
|
Health Check |
|
Auth |
|
Install Confidence |
|
License |
|
Verification |
|
Maintainer |
|
Docs |
|
Support |
|
Executes multi-step autonomous agent reasoning, code synthesis, and tool orchestration via Google Antigravity Agent.
| Name | Required | Description | Default |
|---|---|---|---|
| goal | Yes | High-level autonomous task objective |
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, and it discloses almost nothing behavioral. It does not say whether the agent executes real code or takes side-effecting actions, how long it may run, whether it can spend tokens/money autonomously, or what it returns. For an autonomous orchestration tool this is a significant gap.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Is the description appropriately sized, front-loaded, and free of redundancy?
One front-loaded sentence with no filler; the core capability list arrives immediately. Nothing in the text is redundant with the name or schema.
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 high-complexity autonomous agent tool with no annotations and no output schema, the description is too thin: it omits return shape, run limits, side-effect profile, and any routing guidance against the six sibling tools. An agent could invoke it, but not confidently or correctly in edge cases.
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?
There is a single parameter with 100% schema description coverage ('High-level autonomous task objective'), so the schema already does the heavy lifting. The description adds no guidance on how to phrase the goal, expected scope, or decomposition hints, so the baseline of 3 is appropriate.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Does the description clearly state what the tool does and how it differs from similar tools?
The description names a specific verb ('executes') and three concrete capabilities: multi-step autonomous reasoning, code synthesis, and tool orchestration. That is enough to separate it from sibling media/embedding/search tools, though it never explicitly names an alternative, 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 statement of when to use this versus deep_research_pro_dossier or gemini_universal_generate, which are the closest overlaps for general-purpose generation and research. No prerequisites, no exclusions, no cost or scope caveats are given.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Synthesizes multi-hop grounded technical and market research dossiers with verified citations.
| Name | Required | Description | Default |
|---|---|---|---|
| query | Yes | Deep research topic or investigation query |
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
With no annotations, the description carries the full behavioral burden. It discloses meaningful traits—multi-hop processing, grounding, and verified citations—but omits operational details such as permissions, latency, cost, or output structure, leaving clear gaps for an agent to infer.
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 or redundancy. Every word contributes to specifying the tool's purpose and output.
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 complex multi-hop research tool with no annotations and no output schema, the description states purpose and output essence (dossiers with citations) but lacks usage context, operational details, and return format specifics. It is minimally adequate but noticeably incomplete for the tool's complexity.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
Schema description coverage is 100%, so the single query parameter is fully documented in the schema. The description adds only marginal domain context ('technical and market research') beyond 'Deep research topic or investigation query,' so the baseline of 3 applies.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Does the description clearly state what the tool does and how it differs from similar tools?
The description gives a specific verb (synthesizes) and resource (multi-hop grounded technical and market research dossiers with verified citations), clearly communicating what the tool produces. It does not explicitly differentiate itself from siblings, but none of the listed siblings overlap obviously with research dossier synthesis, leaving the scope understandable without opening schemas.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Does the description explain when to use this tool, when not to, or what alternatives exist?
There is no explicit guidance on when to use this tool versus alternatives, nor any exclusions or prerequisites. The only hint is the schema parameter description 'Deep research topic or investigation query,' which implies usage but does not constitute actionable guidance.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Real-time Google Search and Google Maps grounded reasoning returning structured JSON with source URLs.
| Name | Required | Description | Default |
|---|---|---|---|
| topic | Yes | Search or geospatial query |
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
With no annotations, the description carries the full burden, yet it only discloses that responses are real-time and returned as structured JSON with source URLs. It omits permission needs, rate limits, freshness/recency semantics of 'real-time', and how grounded results differ behaviorally from non-grounded siblings.
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 tight sentence with the capability and return format front-loaded. No filler or redundancy.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
For a single-parameter tool with no output schema, the description usefully signals the return shape (structured JSON with source URLs). It is largely complete, though the absence of any usage/routing guidance against the numerous siblings leaves a small gap.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
Schema coverage is 100% and the single 'topic' parameter is documented as 'Search or geospatial query'. The description adds no extra syntax, format, or examples beyond what the schema already provides, so the baseline of 3 applies.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Does the description clearly state what the tool does and how it differs from similar tools?
The description states a specific capability: real-time grounded reasoning over Google Search and Google Maps with structured JSON output. It is clear about the verb+resource and return type, but draws no boundary against siblings like deep_research_pro_dossier or gemini_universal_generate, which could plausibly handle similar research/generation tasks.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Does the description explain when to use this tool, when not to, or what alternatives exist?
There is no when-to-use or when-not-to-use guidance, and no alternatives are named. An agent must infer from the name alone that this is the proper choice when grounded Google Search/Maps data is wanted rather than generic generation or embeddings.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Account-less inference across all 45 Google Gemini models (Gemini 4 Argon, Gemini 3.1 Pro, Gemini 3.8 Flash) with configurable thinking budgets.
| Name | Required | Description | Default |
|---|---|---|---|
| model | No | Model ID (e.g. gemini-4-argon, gemini-3.1-pro, gemini-3.8-flash) | |
| prompt | Yes | Prompt or instruction for Gemini |
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
With no annotations, the description carries the full behavioral burden. 'Account-less' usefully discloses that no API key is required, but 'configurable thinking budgets' references a control that the schema does not expose, and there is no mention of rate limits, output format, or failure 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?
A single front-loaded sentence with no filler. The only weakness is that '45 models' followed by three example names creates a small inconsistency the reader must reconcile.
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 inference tool with no output schema, this is close to adequate, but it omits return-shape expectations, latency/cost characteristics, and any behavior signals that would matter given zero annotation coverage. The un-backed 'thinking budgets' claim also leaves a gap an agent cannot resolve.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
Schema description coverage is 100%, so the model and prompt parameters are already documented in structured data, giving a baseline of 3. The description adds no syntax, default, or format detail beyond the schema's examples.
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 ('Account-less inference across all 45 Google Gemini models'), which clearly separates it from embedding, image-gen and media-gen siblings. It lacks explicit sibling differentiation in text, but the resource is distinct enough to route an agent correctly.
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 tool versus the six siblings, nor on how to choose among the models. There is no mention of prerequisites, task suitability, or exclusions, leaving selection entirely to inference.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Generates 3072-dimensional semantic vector embeddings via Gemini Embedding 2 for RAG and agent memory.
| Name | Required | Description | Default |
|---|---|---|---|
| text | Yes | Text to embed |
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
With no annotations, the description carries the full behavioral burden. It usefully discloses the output dimensionality (3072) and model lineage, which goes beyond the schema, but says nothing about return format (float array), input token limits, cost, or rate 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?
A single front-loaded sentence with zero filler. The most decision-relevant facts (what it produces, dimension, model, purpose) all appear 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?
For a one-parameter embedding tool with no output schema, the description covers the essentials and even hints at the output shape via the 3072 dimension. It stops short of input constraints or return-format specifics, but nothing critical 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 single 'text' parameter is documented in the schema as 'Text to embed'. The description adds no parameter-level detail (e.g., max length, encoding), so the baseline 3 for a fully-covered schema is correct.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Does the description clearly state what the tool does and how it differs from similar tools?
States a specific verb ('Generates') and resource ('3072-dimensional semantic vector embeddings'), plus the underlying model (Gemini Embedding 2). The embedding modality is unambiguous and clearly distinct from the search, generation, image, and media siblings.
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 trailing phrase 'for RAG and agent memory' implies the intended use context, which is better than nothing. However, it names no alternatives and gives no when-not guidance (e.g., no batch vs single-text routing, no fallback model), so usage is only implied.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Generates high-resolution images, diagrams, and UI assets using Nano Banana Pro (Gemini 3 Pro Image) and Nano Banana 2.
| Name | Required | Description | Default |
|---|---|---|---|
| model | No | gemini-3-pro-image or gemini-2.5-flash-image | |
| prompt | Yes | Visual generation prompt |
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
With no annotations, the description carries the full behavioral burden, yet it discloses nothing about cost, latency, rate limits, output format (URL vs. inline bytes), or resolution. 'High-resolution' is an unquantified claim and no mutation/safety profile is described.
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, leading directly with the verb and output types. It is efficient, though the brevity contributes to the gaps noted in other dimensions rather than being pure economy.
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 generative tool with no output schema and no annotations, the description is thin: it does not say what the caller receives back, how the two models differ, or when to prefer this over sibling media generators. It is adequate to identify the tool but incomplete 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?
Schema description coverage is 100%, so both parameters (prompt and model, including the two model identifiers) are already documented in the schema. The description adds no format, syntax, or prompt-construction guidance beyond what the schema provides, making the baseline 3 appropriate.
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 (generates) and concrete output types (high-resolution images, diagrams, UI assets), so the agent knows exactly what the tool produces. It does not, however, differentiate itself from siblings like veo3_and_lyria3_media_gen or gemini_universal_generate, leaving the boundary 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?
There is no when-to-use guidance, no mention of alternatives, and no routing hints despite six sibling tools that overlap in the generative-media space. The only selection signal is the model parameter, which lives in the schema rather than the description.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Generates cinematic video clips via Veo 3 or studio audio tracks via Lyria 3.
| Name | Required | Description | Default |
|---|---|---|---|
| prompt | Yes | Video or music synthesis prompt | |
| media_type | No | video or music |
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 not disclose whether generation is synchronous or asynchronous, expected latency, cost implications, authentication requirements, or rate limits. It only states what it generates.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Is the description appropriately sized, front-loaded, and free of redundancy?
The description is a single, front-loaded sentence that immediately states the tool's purpose. It contains no unnecessary words or 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?
The tool is simple with two parameters and a fully described schema. The description states the purpose but omits usage context and behavioral traits. Given the absence of annotations and an output schema, more context about when to use it and what to expect would improve completeness.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
Schema description coverage is 100%, so the schema already documents both parameters. The description adds no additional syntax, format, or constraint details for 'prompt' or 'media_type' beyond what the schema provides.
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 'Generates' and specific resources 'cinematic video clips' and 'studio audio tracks', naming the underlying models Veo 3 and Lyria 3. It distinguishes from siblings like nano_banana_pro_image_gen by focusing on video/audio rather than images. However, it does not explicitly state what it is not for or compare to alternatives.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Does the description explain when to use this tool, when not to, or what alternatives exist?
No explicit when-to-use or when-not-to-use guidance is provided. The description implies it is for generating video or audio, but does not say when to choose this over gemini_universal_generate or nano_banana_pro_image_gen, nor how to select between video and audio modes.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Recent tool additions, removals, and schema changes observed during successful MCP inspections.
v1.4.0antigravity_autonomous_agentdeep_research_pro_dossiergemini_grounded_search_mapsgemini_universal_generategemini_vector_embeddingsnano_banana_pro_image_genveo3_and_lyria3_media_genScored across 7 tools
Image, video/audio, and embeddings tools are clearly distinct, but a cluster of four tools (gemini_grounded_search_maps, deep_research_pro_dossier, antigravity_autonomous_agent, gemini_universal_generate) all perform text/research reasoning, making it hard to know which to pick for a given query. Descriptions hint at differences (grounding, multi-hop citations, autonomy) but boundaries remain fuzzy.
Conventions are mixed: gemini_grounded_search_maps, gemini_universal_generate, and gemini_vector_embeddings use a gemini_*_<verb> pattern, while antigravity_autonomous_agent, deep_research_pro_dossier, nano_banana_pro_image_gen, and veo3_and_lyria3_media_gen are product/noun phrases with no consistent action verb. The set reads as a collection of marketing names rather than a predictable scheme.
Seven tools is well-scoped for a multimodal Gemini suite, with one tool per major capability (search, generate, agent, research, image, media, embeddings). No tool feels redundant or padded.
The surface covers the core generative modalities (text, search/maps, research, images, video/audio, embeddings) and gives a clean lifecycle for each. Minor gaps exist around downstream operations like image/video analysis or editing, but agents can work around them.
AI agent tools: web search, browser, 400+ LLMs, image gen, TTS, phone verify. Pay-per-use.
247 LLMs + image/video/voice/music gen + crypto/DeFi/markets/web-search. Pay-per-call USDC, no key.
Image, video, music and text generation across 100+ models through one endpoint.
Pay-per-call agent tools over x402 (USDC on Base) — no signup or API key.
