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

Annotations already declare readOnly/openWorld/non-destructive, but the description adds what they cannot: it consumes no credits nor usage limit, the full run costs ~30 s, it only opens and closes menus, nothing is generated or altered, and a truncated run reports which part was skipped. It even names where failures surface (src/seletores.ts).

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, cost-free guarantee and trigger condition are front-loaded, and the dense detail that follows is mostly load-bearing. There is mild repetition between 'Não gasta créditos nem o limite de uso' and 'nada é gerado nem alterado', and the completo=true explanation is spread across two long 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?

There is no output schema, so the description must describe the return, and it does: it names which item changed, where that item lives in src/seletores.ts, and which part was missing on truncation. For a read-only diagnostic with a 3-param, fully documented schema, nothing an agent needs is absent.

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

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

Schema coverage is 100%, so the baseline is 3; the description goes further by tying completo=true to the ~30 s full-screen sweep and by restating the parte values (notebooklm, flow, drive) in the timeout fallback. It omits the enum's fourth value 'tudo' and says nothing about how the 'notebook' parameter is chosen beyond what the schema already states.

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 full scope: it checks login, NotebookLM and Flow (screens, menus, balance) and reports what is working or broken. That clearly separates it from the many action siblings (flow_gerar_video, notebook_criar, etc.) and from narrow status tools, since this is the aggregate health check.

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 trigger: 'Use quando algo der erro ou parecer que o Google mudou a tela', and a recovery path when the call times out (re-call with parte). It never names which cheaper sibling to use for a narrow check (login_status, flow_status, flow_creditos), so the alternative selection is left implicit.

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/non-destructive/openWorld, so the description correctly focuses elsewhere: it discloses that results are paged ('em partes') and confined to the outputs folder, which the annotations do not cover. It does not state chunk size or total part count, but the paging model itself is a meaningful addition.

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 leads with the internal-use constraint, then explains the mechanism. No filler, and the most important warning comes first.

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 2-parameter internal tool with full schema coverage and clear annotations, the description gives the agent everything it needs: what it returns, from where, in what shape, and that it should not be called directly. Only the chunking size semantics are left implicit, which is minor for a tool agents shouldn't invoke.

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 (nome, parte) are documented there with bounds, so the baseline applies. The description's 'em partes' reinforces the parte parameter's intent but adds no format or sizing detail 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 concrete verb and resource: it returns a file from the outputs folder, chunked into parts, and explicitly scopes the tool to the Claude Desktop viewer (Download/Watch/Listen buttons). That scoping cleanly separates it from siblings like flow_baixar without needing 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?

Provides an explicit exclusion: 'Não use diretamente' with the condition that it is internal to the viewer buttons. It stops short of naming the sibling an agent should use instead for agent-initiated downloads (e.g., flow_baixar), so routing is clear but not fully closed.

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

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

Goes well beyond the annotations by disclosing that files ALWAYS land in a fixed path regardless of whether the caller is Claude Code or Claude Desktop, and that 1080p/2k are Flow-enhanced variants with the credit balance (saldo) checked before and after — a real cost side effect that annotations (readOnlyHint=false, destructiveHint=false) do not convey. It does not specify filename conventions or whether an existing file is overwritten, which matters for a disk-writing tool.

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

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

Three sentences, front-loaded with the action and resource, then the destination path, then the quality semantics. The parenthetical '(vídeo estendido)' and the Claude Code/Desktop clause are justified because they disambiguate scene type and explain why the path is fixed. Slight redundancy in restating the destination twice.

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

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

With no output schema, the description must convey the result, and it does only loosely — a directory path is given, but not the returned file name, whether a result payload lists the saved files, or what happens on collision. The path itself is garbled with mixed separators ('/app/%LOCALAPPDATA%\mcp-google/saidas/flow'), which an agent cannot reliably interpret.

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?

At 67% schema coverage the description carries real weight: it explains that 'original' is the file exactly as generated while '1080p' applies to video and '2k' to image and consumes credit. That adds meaning the enum alone does not. It omits the 'gif' enum value entirely, leaving one valid quality mode undefined 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?

States a specific verb (baixa) and a precise resource scope: an image, video, or scene (extended video) already generated in Flow, retrieved by id. An agent can tell it apart from generation siblings (flow_gerar_imagem, flow_gerar_video, flow_estender_video) because the media must already exist. It does not, however, differentiate itself from nearby siblings like flow_arquivo or flow_estudio_baixar-style downloaders.

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 'já gerada' (already generated), so the agent infers this is a post-generation retrieval step, but there is no explicit when-to-use statement, no mention that an id must first come from flow_listar, and no statement of when not to use it. The alternative among sibling downloaders 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 readOnlyHint=true and destructiveHint=false, so the safety profile is covered. The description still adds real context beyond them by promising the call consumes no credits, which matters in a family where most flow_* tools do spend credits.

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

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

One short sentence, front-loaded with the action and resource, with the no-cost caveat tucked into a parenthetical. Nothing superfluous and nothing 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?

For a zero-parameter read tool this covers what an agent needs: what it returns conceptually (credit balance) and that it is free to call. It does not say whether the balance is broken down per model or account-wide, but no output schema or params create obligations here.

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

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

The tool takes zero parameters, so there is nothing for the description to disambiguate; baseline 4 applies. The schema is empty and fully consistent with the described read-only balance check.

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: shows the Google Flow credit balance for the account. It implicitly separates itself from the spend-tracking siblings (flow_gastos, flow_custo) by being a balance read, though it never names them 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 parenthetical '(não gasta nada)' implies it is safe to call at any time, and the credit framing suggests it belongs before credit-consuming operations like flow_gerar_video. However, no explicit when-to-use guidance or routing to flow_gastos / flow_custo / flow_status 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?

The description is consistent with readOnlyHint=true and reinforces it by stressing that nothing is generated, and it discloses that the returned value matches exactly what the Flow UI shows. It does not cover edge behavior such as invalid model handling or where the cost baseline comes from beyond the UI, so it is good but not exhaustive.

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, and the counterfactual ('SEM gerar nada') is placed where it reads first. Nothing to trim.

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

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

With eight optional parameters, no output schema, and rich parameter descriptions in the schema, the description covers the core contract (simulate, return cost, generate nothing). It could say more about whether the response includes per-item cost breakdown for quantity>1, but nothing essential to calling it correctly 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 75% and the schema already explains model options, duration rules, project resolution, and quantity cost multiplication. The description adds no parameter-level meaning of its own, so the baseline 3 applies.

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

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

States a specific verb and resource (simulate a Flow generation, return credit cost) and explicitly contrasts with generation using 'SEM gerar nada', which cleanly separates it from flow_gerar_video and flow_gerar_imagem. An agent can tell what it does 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?

Implied pre-generation cost check is clear from 'simula ... e devolve o custo', but there is no explicit when-to-use or when-not, and no reference to alternatives such as flow_creditos or flow_gastos. The guidance is inferable but not 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?

Adds substantial context beyond the annotations: cost (0 créditos em out/2026), non-destructive behavior toward the original image, an automatic PT→EN prompt translation that can corrupt in-image text, and a fixed output directory shared across Claude Code and Claude Desktop. These are exactly the operational surprises an agent needs warned about 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?

Front-loaded with the core action and examples before the caveats and the path note. The final sentence about /app/%LOCALAPPDATA%\mcp-google/saidas/flow is dense and slightly awkward, but every sentence carries information an agent would otherwise lack.

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

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

For an 8-parameter generative tool with no output schema, the description covers cost, output location, source-image preservation, and translation risk. It stops short of saying what is returned (paths? image ids? one item per variation), which matters given the 'quantidade' parameter, but that is the only notable 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 88%, so the baseline is 3; the description earns an extra point by clarifying that 'imagem' is used as a reference and that 'instrucao' is written in Portuguese and may be machine-translated. Repeating the textual-override syntax for 'instrucao' gives the parameter practical semantics the schema alone doesn't convey.

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: 'Edita uma imagem existente com Nano Banana', using the source image as reference plus an instruction. The examples ('troque o fundo por uma praia', 'deixe em estilo aquarela') make it immediately distinguishable from flow_gerar_imagem, and the closing note 'Gera uma imagem nova; a original não muda' pins down the operation's nature.

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 supplies concrete usage examples and the transformation scenario the tool is meant for, plus a caveat-driven workaround ('para manter, diga "texto exatamente em português: ..."'). It does not explicitly name flow_gerar_imagem as the alternative for images that don't yet exist, so the boundary 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?

Annotations only declare readOnly=false, openWorld=true and destructive=false; the description adds the material behaviors: real cost is read before generating (~10 credits), the model may be silently overridden by Flow with a warning in the response, output always lands in a fixed local path, and the call is slow (~1-3 min) and often returns 'in progress'. This is exactly the context annotations cannot convey.

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 alternative, and every later sentence adds operational value (path, model override, cost, latency). It is dense and slightly repetitive – the Flow model override is stated twice – but nothing is 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?

No output schema exists, yet the description covers where the artifact is written, that generation is asynchronous and must be confirmed via flow_status, and what the response does when the model differs. For a mutation tool with an open-world hint, an agent has everything needed to call it and follow up 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 is 3; the description earns a point by warning that the requested model may not be honored and by naming the credit cost associated with the default model. That said, much of the model caveat is already repeated in the schema's own modelo description, so the added value is modest.

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 ('Continua um vídeo ou uma cena já estendida'), specifies the +~7s scope and the .mp4 output, and explicitly separates it from the sibling flow_video_longo for long multi-segment videos. An agent can tell what this does and what it is not 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 routes long multi-part videos to flow_video_longo and tells the agent to poll flow_status until the save completes on Claude Desktop. It does not contrast against flow_gerar_video (starting a new video vs continuing), which is the other plausible alternative, so it stops short of full when/when-not coverage.

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 readOnlyHint=true and destructiveHint=false, so safety is covered structurally. The description adds useful context beyond that: it reads from this PC's log, does not open the browser, and does not spend credits. There is a mild tension with openWorldHint=true, but it is not a clear contradiction of the local-read behavior 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?

The description is a single efficient sentence with the core report content front-loaded. The parenthetical about local execution and zero cost is compact and directly useful.

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

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

For a simple read-only reporting tool with one optional parameter and no output schema, the description covers what data is reported, where it comes from, and that it is side-effect free. The only small gap is that it does not mention the time-range parameter, though the schema fully documents 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?

There is one optional parameter ('dias'), and the schema description coverage is 100%, so the schema already explains the default of 7 days and the 1–365 range. The description adds no additional parameter semantics beyond what the schema provides, which fits the baseline of 3 for high schema coverage.

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 ('Mostra') and a precise resource: credit spend per day, by type/model, plus the most expensive generations. It also distinguishes the data source as the local PC log rather than a live browser session, though it does not explicitly name sibling tools like flow_creditos or flow_custo.

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: this is for analyzing historical credit consumption from the local log. However, the description does not explicitly say when to use this versus flow_creditos, flow_custo, or other Flow tools, nor does it state exclusions or prerequisites.

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 write/open-world/non-destructive, and the description adds real context beyond them: the fixed output directory, a 20-40s latency estimate, persistence of images in the Flow project, and the async 'em andamento' fallback to flow_status. What's missing is what the call returns on success (paths? ids? credit spend), which matters for a non-read tool.

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

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

Front-loaded with the action, then the output path, latency, and reuse/fallback notes — every sentence carries information. It is dense but slightly overpacked with parenthetical asides that could be trimmed.

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?

Covers the operational facts an agent needs for a 9-param, no-output-schema tool: where files land, how long it takes, and what to do when it times out. Return-value shape (e.g. whether the file path and image id come back in the response) is left implicit.

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 defaults, enums and per-parameter guidance are already documented. The description adds no parameter-level detail beyond echoing the image-as-video-frame idea that is already in the proporcao field description; 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 ("Gera imagens no Google Flow (Nano Banana)") plus the download side-effect, and names the downstream sibling flow_gerar_video it feeds into. An agent can distinguish it from flow_editar_imagem and flow_gerar_video without opening any schema.

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

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

Gives concrete routing: generated image ids can be reused as start/end frames in flow_gerar_video for character continuity, and a slow run routes to flow_status. It does not explicitly contrast with flow_editar_imagem (edit existing vs generate new), so the boundary with that sibling is left implicit.

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 annotations only saying it is a non-read-only, non-destructive open-world call, the description carries real weight: it discloses credit spend per model, that requests exceeding the daily quota are rejected before submission, the 1–3 minute generation time, and the ~50 s Desktop timeout that forces polling. It also fixes the output location. Nothing here contradicts 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?

Information is front-loaded: what it produces, where files land, cost, then the mode conflicts and the async caveat. It is dense but nearly every sentence carries operational meaning; the credit-cost sentence partly duplicates the modelo schema entry.

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 15-parameter, long-running, credit-consuming generation tool with no output schema, the description covers cost, timing, async polling, file destination and mode incompatibilities. It stops short of describing the response payload shape in Claude Code (beyond 'waits and downloads'), which would help an agent parse results.

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 semantics the schema lacks, notably that elementos (personagens/referencias) are mutually exclusive with imagem_inicio/imagem_fim because they are different Flow modes. The credit-cost restatement and the default model repeat the schema's own parameter descriptions, which limits the added value.

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

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

States a concrete verb and artifact ('Gera vídeo curto no Google Flow (Veo 3.1, 8 s com áudio)') plus the side effect of downloading an .mp4 with AI Pro credits. It distinguishes itself from siblings by naming flow_estender_video for durations beyond 8 s and flow_status for polling, so an agent can place it in the flow_* family immediately.

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

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

Gives explicit conditions: image-to-video via imagem_inicio/imagem_fim, elementos for character consistency, and that elementos do not combine with start/end images. It also explains the Claude Desktop vs Claude Code calling pattern. It never explicitly contrasts with flow_video_longo or notebook_gerar_video, which are the neighboring alternatives an agent might pick instead.

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 readOnlyHint=true, destructiveHint=false and openWorldHint=true, so the safety profile is covered. The description adds useful behavior — that it falls back to a default project and that output items carry id/tipo/título/estado — but says nothing about pagination, result limits or how large projects are handled, which matters for an openWorld read tool.

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

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

A single front-loaded sentence with the resource first and the default/output details trailing; every element carries information. It is slightly dense with parentheticals but no sentence 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?

With one optional parameter and no output schema, the description usefully compensates by naming the returned fields, and it explains the default-project behavior an agent would otherwise miss. The only real omission is result-set size or ordering 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 coverage is 100% and the single parameter already documents that id, link or exact name are accepted and that omission falls back to flow_projeto_padrao. The description only repeats the default project name, adding no syntax or format detail beyond the schema, so the baseline 3 applies.

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

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

States a specific verb and resource ('Lista as imagens e vídeos de um projeto do Flow') and enumerates the returned fields (id, tipo, título, estado), which clearly scopes it as a media lister inside a project rather than a project lister like flow_projetos. It stops short of explicitly naming a sibling to contrast with, so a 4 rather than 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?

Usage is only implied by the resource scope; there is no explicit 'use this when…' statement, no mention of when to prefer flow_projetos, flow_arquivo or flow_status, and no note on whether the project must already exist. Minimum viable but with clear gaps.

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 behavior beyond annotations: the portrait is generated by Nano Banana at 0 credits, appears in the chat, corpo costs ~25 extra seconds, and a partial failure returns an ATENÇÃO block with the created name and page link. That failure-mode contract is exactly the kind of context annotations (readOnly=false, destructive=false, openWorld=true) cannot convey.

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 invocation, then failure recovery, then downstream usage — a sensible order. It is dense and slightly over-stuffed (credit pricing tied to 'out/2026', provider name) for a tool description, which keeps it from a 5.

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

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

No output schema, and the description compensates by describing what the agent gets back (portrait in the chat, ATENÇÃO block on partial failure with name and link) and how to reference the character later. For a 7-parameter creation tool with open-world behavior, nothing essential to 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 coverage is 100%, so baseline is 3; the description still adds value by spelling out the descricao/imagem either-or decision and the appearance facets the descricao should cover (espécie/rosto, cabelo, roupa, estilo), plus that corpo also triggers a full-body image. It does not go deeper on projeto or voz than the schema already does, so not 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 ('Cria um personagem do Google Flow') plus the scope that distinguishes it: a reusable asset for 'vários vídeos e imagens com a mesma aparência (e voz)'. It names the sibling it is not (flow_personagem_editar) and the downstream tools, so an agent can differentiate it from flow_personagem_editar/excluir 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?

Gives the two mutually exclusive input paths explicitly ('Informe nome e descricao ... OU uma imagem'), lists optional fields, and states the failure-handling alternative: correct with flow_personagem_editar (nome: the link) 'em vez de criar de novo'. It also tells the agent how to consume the result ('Depois use personagens: [nome] em flow_gerar_video / flow_gerar_imagem').

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 readOnlyHint=false and destructiveHint=false; the description adds real value by disclosing that regenerating the body image overwrites the current one but the previous version is preserved in the Flow page history. It omits permission/auth requirements and whether partial updates are allowed, keeping it below 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 sentences, zero waste, with the primary capability front-loaded and the caveat about body regeneration following immediately. Every clause carries information.

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

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

For a 6-param mutation tool with no output schema, the description covers the main behaviors and the risky one (body regeneration) adequately. It could still clarify the return value (e.g., whether an image URL comes back) and the rename interaction, so it is strong but not exhaustive.

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 67%, with the key parameters (voz, nome, corpo, projeto) already self-documented. The description adds the non-obvious overwrite semantics of 'corpo' but says nothing about novo_nome or personalidade beyond naming them, leaving two undocumented schema params untouched.

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 ('Muda nome, personalidade ou voz de um personagem') plus the secondary capability of generating a full-body image, which an agent can distinguish from flow_personagem_criar / flow_personagens by name alone. It does not explicitly say 'use X to create instead', so it stops short of 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?

It gives one useful conditional rule — that passing 'corpo' regenerates an existing body image — but never states when to pick this tool over flow_personagem_criar, flow_editar_imagem, or flow_gerar_imagem. Usage is implied rather than directed.

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 destructiveHint=true, and the description adds real value on top: the deletion is permanent and gated on explicit user confirmation of the name. It does not disclose side effects (e.g., what happens to videos or projects that reference the character), which is the remaining gap for an irreversible operation.

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, zero redundancy, with the destructive nature front-loaded and the usage restriction immediately after.

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 full schema coverage, annotations carrying the safety profile, and no output schema to explain, the description covers what an agent needs to call it correctly. The one missing piece is the blast radius of the deletion, which matters for a permanently destructive tool.

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

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

Schema description coverage is 100%, so the schema already explains nome, projeto and the confirmar const. The description's 'confirmar o nome' only loosely ties to the nome parameter and adds no format or disambiguation detail 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 and resource ('Exclui um personagem do Flow') and adds the irreversible qualifier 'PERMANENTEMENTE', which cleanly separates it from flow_personagem_editar, flow_personagem_criar and flow_personagens without needing to name 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 precondition for use: only when the user explicitly asks for deletion and confirms the name. It does not name an alternative tool (e.g., flow_personagem_editar for non-destructive changes), so it stops just short of the top score.

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 readOnlyHint=true and destructiveHint=false, so the safety profile is covered. The description adds that only character names are returned (not full objects), which is mildly useful, but says nothing about ordering, empty-project behavior, or default resolution beyond what the schema states.

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 short sentence with the resource stated first and the usage hint trailing. No filler, though the parenthetical slightly dilutes the front-loaded statement.

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?

A simple read-only tool with one optional, fully documented parameter and annotations covering its behavior. An agent has everything needed to invoke it correctly; no output schema is required for a list of names.

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 `projeto` parameter already documents id/link/name and the default fallback to flow_projeto_padrao. The description adds no additional parameter meaning, so the baseline 3 applies.

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

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

States a specific verb and resource ("Lista os nomes dos personagens do projeto do Flow") and even narrows the return to names, which separates it from the sibling mutation tools flow_personagem_criar/editar/excluir. It does not explicitly name those siblings as alternatives, keeping it 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 parenthetical "(para usar em personagens: [...] nas gerações)" gives a downstream purpose, implying why an agent would call it. However, there is no explicit guidance on when to prefer this over flow_projetos or flow_listar, 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?

Annotations already declare readOnlyHint=false, destructiveHint=false and openWorldHint=true. The description adds real value beyond them: it says the call costs no credits and discloses the project-scoping side effect on characters. It still does not say what the call returns or how the new project is identified afterwards.

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 short sentences, front-loaded with the action, then the cost note, then the caveat. Every sentence carries information; only the example parenthetical is optional 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?

No output schema exists, so a note on what is returned (e.g., the new project identifier needed for later calls) would be the missing piece. Otherwise the cost profile, prerequisite and scoping behavior are all covered for a two-parameter creation 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 coverage is 100% and both parameters (nome, tornar_padrao) are documented in the schema. The description only restates that the project takes the given name and says nothing about tornar_padrao or the name-uniqueness / 80-char constraint, so it adds little over 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 and resource ("Cria um projeto novo no Google Flow com o nome dado") plus a concrete grouping example (one per video or series). The resource distinguishes it from list/character tools, though it never names a sibling it could be confused with.

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 the selection intent (a project per video or per series) and a concrete prerequisite: characters are project-scoped, so in a new project you must recreate them with flow_personagem_criar before use. Names that alternative explicitly, but gives no explicit when-not-to-use case.

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 annotations already declaring a non-read-only, non-destructive, open-world mutation, the description adds useful behavior: the choice is persisted in local config.json and applies to both Claude Code and Desktop. It does not discuss validation or failure behavior if the project does not exist, but the persistence and scope are 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?

A single front-loaded sentence with no wasted words. It states the action, the condition, the persistence location, and the platform scope in one compact statement.

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 configuration tool with no output schema, the description covers the essential behavior: what the setting changes, where it is stored, and which clients it affects. It could mention what happens if the project is invalid or how to clear the default, but nothing critical for normal 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 the schema already documents the single 'projeto' parameter and its accepted forms. The description implies this parameter becomes the default when omitted elsewhere, but adds no syntax or format details 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?

The description states a specific action (choosing the default Flow project) and the exact condition under which it matters (when 'projeto' is not provided). It clearly distinguishes the tool from siblings like flow_projetos (listing projects) or flow_projeto_criar (creating projects).

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

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

It clearly explains when the setting takes effect: when 'projeto' is omitted by Flow tools. It does not explicitly name alternatives or exclusions, but the context is enough for an agent to know this is a configuration tool rather than a listing or creation tool.

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

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

Annotations already declare readOnlyHint=true, openWorldHint=true, destructiveHint=false, so the safety profile is covered. The description adds non-obvious value with "Não gasta nada" (no credit/cost consumption) and by disclosing the default-project concept, which an agent needs to interpret results correctly.

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 sentence that leads with the action and resource, then adds the default-project context and the no-cost note. Nothing is redundant with the title beyond the necessary restatement of the verb.

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

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

With no output schema, the description carries the burden of describing results and does so by listing the returned fields plus the default-project indicator. Minor gaps remain (no mention of list size, ordering, or empty-account behavior), but an agent has enough to call it correctly.

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

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

The tool takes zero parameters, so the baseline of 4 applies. The description correctly does not invent parameter guidance, and the returned field semantics it does mention (nome, link, data) are output-side information the schema cannot convey.

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 ("Lista os projetos da conta no Google Flow") and even enumerates returned fields (nome, link, data), so the operation is unmistakable. It does not name any sibling tool, so differentiation from tools like flow_projeto_criar or flow_projeto_padrao is only implied.

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?

Usefulness is implied by "qual é o padrão usado quando nenhuma ferramenta recebe 'projeto'", which hints at when the listing matters (resolving default project context), but it never says when to call this versus flow_listar, flow_projeto_padrao, or flow_projeto_criar.

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 annotations only covering readOnly/openWorld/destructive, the description carries the real behavioral load: the daily mcp-google cap is checked before sending, only what fits the call window is submitted while the rest is queued, and the total estimated cost is surfaced. It also discloses the fixed output location /app/%LOCALAPPDATA%\mcp-google/saidas/flow regardless of client.

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 what the tool does, then queue/polling behavior, then the cost-saving tip, then output location — a sensible priority order with no filler. It is dense but every sentence carries operational information an agent needs; only the model cost table is arguably duplicated from the 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?

No output schema exists, yet the description covers the asynchronous contract (partial submit, queue, flow_status loop), the cost preview, the daily-cap precondition, and where files land — everything needed to call and follow up on an open-world, non-read-only 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 coverage is 80%, so the baseline is already 3; the description adds value by framing cost as 'cenas × custo do modelo' and by constraining max_creditos_total to explicit user requests while noting the daily cap always applies. It does not re-explain the per-scene fields (personagens, referencias, imagem_inicio), which is correct since the schema already documents them.

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

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

Opens with a specific verb+resource+scope: 'Gera várias cenas de vídeo de uma vez (até 10)'. The batch framing plus the per-scene fields distinguishes it from the single-video sibling flow_gerar_video without needing to inspect either schema.

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

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

Gives explicit operational routing: call this, then 'Repita flow_status até terminar' to push queued scenes and download finished videos. It also names an alternative workflow (generate stills first with flow_gerar_imagem, 0 créditos, then pass them as imagem_inicio) and states a when-not for max_creditos_total ('só use se o usuário pedir').

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 beyond the annotations by disclosing that the call blocks and waits only within the call's time budget, and that files are always written to a fixed path (/app/%LOCALAPPDATA%\mcp-google/saidas/flow) regardless of client. This is useful side-effect context for a tool marked readOnlyHint=false. It omits timeout length and what is reported for items still pending.

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 that are front-loaded with the polling/download purpose, followed by the repeat instruction and the output-path caveat; there is no filler. The path sentence is long but carries information an agent cannot infer 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?

No output schema exists, and the description covers the essential return-side behavior: it downloads finished files and signals via 'repeat until nothing pending' that some work may remain. What the tool actually reports back for still-pending items is left unstated, a minor gap.

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

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

Schema description coverage is 100%, so the single 'lote' parameter is already documented in the schema; baseline 3 applies. The description never mentions the batch/media id at all, so it adds nothing on parameter behavior 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?

States a specific verb and resource: it monitors in-progress generations (videos, images, extensions), waits during the call, and downloads completed output. However, it never distinguishes itself from the closely related siblings flow_listar and flow_baixar, whose scopes could plausibly overlap with this one.

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 line 'Repita até não haver mais nada pendente' gives an explicit polling pattern, which is genuine usage guidance. But it gives no recommendation for choosing it over flow_listar or flow_baixar, and no exclusion that says when not to call 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?

Goes far beyond annotations: discloses per-model credit cost (lite 10 / fast 20 / quality 100 + 10 per extension), ~1-2 min per segment, the personal daily ceiling check before submission, removal of Flow's ~1s seam pauses with the original kept alongside, and the fixed output directory. These are material side effects an agent must know 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?

Purpose and the recommended mode are front-loaded, and every clause carries operational weight for a 19-parameter tool. It is dense and run-on in places, so slightly less scannable than ideal, but there is little filler.

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

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

For a costly, long-running generation tool with 19 params and no output schema, it covers cost, timing, the status-polling lifecycle, output location, and failure/retomar handling. Nothing needed to invoke it correctly 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%, but the description adds real cross-parameter semantics: word counts per segment (~15-19 first, ~13-17 extensions), extensions are always Veo 3.1 Lite so characters can't change location, personagens/voz go in all segments via elementos_em_todos while referencias/imagem_inicio apply only to the first, and restricoes is repeated in every prompt.

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: produces one continuous, uncut video by chaining an 8s base segment with ~7s extensions that the MCP merges into a single .mp4. The extension mechanism and the 'junta tudo' merge distinguish it from sibling flow_gerar_video and flow_estender_video.

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 recommends the 'cenario'+'falas' presenter mode and reserves 'trechos' (free text) for when each prompt must be controlled. Also specifies post-call behavior: only repeat flow_status until PRONTO, and never re-call this tool for the same video. Behavior with no trechos and no retomar is also 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 the read-only, non-destructive, open-world profile, so the description's added value is 'Não gasta nada' — a concrete cost guarantee that the annotations do not express. It also previews the returned fields, which matters since no output schema exists; volume or ordering of results is still undisclosed.

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 compact sentences: purpose and payload first, cost reassurance second. Nothing is repeated and nothing is padded.

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

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

For a zero-required-param read tool this covers the essentials: what it returns, what it costs, and where the output is consumed. Only minor gaps remain, such as how many voices come back and whether results are pre-filtered.

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 optional 'busca' parameter is fully documented in the schema with examples. The description says nothing about filtering, so it adds no meaning beyond structured data — the expected baseline of 3.

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 ('Lista as vozes do Flow') and enumerates what each entry contains (nome, gênero, timbre). It also names the consumer tool flow_gerar_video, which anchors it against siblings, though it does not explicitly exclude any alternative.

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

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

The phrase 'para usar em voz de flow_gerar_video e na voz dos personagens' tells the agent exactly the situation that calls for this tool: choosing a voice before generation or character creation. There is no explicit when-not-to-use guidance, keeping it below a 5.

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, it discloses important behavior: the browser is a normal Edge window without automation, the login is manual, and the MCP does not see or store the password. It does not explain whether the call blocks until login completes or what happens if the user closes the 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?

Three short sentences, front-loaded with the core action and followed by privacy and usage guidance. There is no wasted text.

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 parameterless, output-schema-free tool, the description covers the mechanism, privacy implications, and trigger condition well. The main gap is that it does not connect to login_status, which is the obvious sibling for verifying or checking login state.

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

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

The tool has zero parameters, so there is no parameter semantics to document. This matches the baseline of 4 for a parameterless tool.

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 action and mechanism: opening a normal, non-automated Microsoft Edge window so the user can log into Google manually. It is clear what the tool does, but it does not explicitly distinguish itself from the sibling login_status tool.

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

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

It gives an explicit trigger: use when another tool reports that the session expired. It does not name login_status as the companion tool for checking session state or state any cases where this tool should not be used.

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 readOnlyHint=true, destructiveHint=false and openWorldHint=true, so the safety profile is covered. The description adds the useful scoping detail that the check targets the local profile, but says nothing about what an inactive result means or what the agent should do next. With annotations doing the heavy lifting, a 3 is appropriate.

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. It is tight but also thin — nothing is wasted, yet nothing extra is offered.

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

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

For a simple 0-param read-only check with annotations and no output schema, the description is adequate to call the tool. It stops short of telling the agent what the result implies or which sibling to invoke when the session is not active, leaving a real gap in an otherwise simple case.

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

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

Zero parameters and 100% schema coverage, so there is nothing for the description to disambiguate. No parameter claims are made or needed; baseline for a 0-param tool 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 ('Confere') and a specific resource ('sessão do Google... no perfil local'), so an agent knows this reports session state rather than performing a login. It is distinguishable from login_iniciar by implication (check vs. start), but the sibling is never named, so differentiation is inferential.

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 word 'Confere' and the status framing imply this is a pre-flight check to run before authenticated Google operations, but the description never states when to call it, when not to, or that login_iniciar should follow an inactive result. Usage is implied only.

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 declare readOnly=false, destructive=false and openWorld=true; the description adds real behavioral context: the call blocks while NotebookLM processes, each file is capped at 200 MB, and the response reports type and size of every new source. It omits failure/timeout behavior and duplicate handling, but that is a minor gap.

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

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

Two sentences, front-loaded with the action and the one-type-per-call rule, with the format list compressed into a single parenthetical. Nothing is wasted despite covering five input modes.

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

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

With no output schema, the description usefully states the return summary (type and size per new source), and it covers the size and format limits an agent needs before calling. Only edge cases like oversized batches, unsupported formats, or processing failures are unaddressed.

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

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

Schema coverage is already 100%, so the baseline is 3, but the description genuinely adds meaning beyond it: it clarifies that url accepts several links, that arquivos needs full PC paths in specific formats with a 200 MB limit, and that drive takes an exact name or file link. The notebook parameter's id/URL/partial-title resolution is left to the schema.

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

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

States a specific verb and resource ('Adiciona fontes a um notebook') and then enumerates exactly which source kinds are accepted (url/texto/arquivos/drive). An agent can tell this is the ingestion tool, distinct from siblings like notebook_fontes or notebook_fonte_remover, though no sibling is named explicitly.

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

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

'Use UM tipo por chamada' is an explicit, non-obvious usage constraint that prevents an agent from combining url+texto+arquivos in one call. It does not, however, say when to prefer this over alternatives or what to do if a source already exists – so no exclusions or routing are provided.

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 readOnlyHint=false, destructiveHint=false and openWorldHint=true, so the mutation/safety profile is covered. The description reinforces the configuration nature and the 10,000-character limit, but adds nothing about whether this is a full overwrite of existing chat settings, what happens to the notebook's current configuration, or what is returned on success.

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 dense sentence that front-loads the outcome ('define como o chat responde') and then enumerates the two configurable dimensions. Nothing is wasted, though the parenthetical makes it slightly dense to parse.

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 annotations covering the mutation profile and a fully described schema, the definition is workable. Still missing for a mutation tool: whether changes replace existing settings, whether partial updates are allowed, and the absence of any output schema or mention of the response shape.

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 all four parameters (including the notebook identifier and the enum meanings) are already documented in the schema. The description restates the objetivo modes and the instruction length cap but adds no semantics beyond the structured fields, 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: it defines how the notebook chat responds, naming the two configurable axes (objetivo and tamanho das respostas) plus the 10,000-character cap for custom instructions. An agent can distinguish this configuration tool from conversational siblings like notebook_perguntar or notebook_conversa, though no sibling is named explicitly.

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

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

Usage is only implied — an agent infers this is the tool for tuning chat behavior rather than asking questions. There is no explicit when-to-use/when-not, no mention of prerequisites (e.g., the notebook must exist), and no note about whether configuring replaces prior settings.

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 read-only and non-destructive, yet the description adds real value: one file per call with date/time, the exact output directory, quota-free operation, inclusion of exact source excerpts with citation markers, and a prompt-injection warning about treating source text as data. The path string is garbled ('/app/%LOCALAPPDATA%\mcp-google/...'), which mutes an otherwise strong disclosure.

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

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

Three sentences, opening with the core action and payload, then the output location, then the cost/security caveats. No filler and each sentence carries 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?

With no output schema, the description takes on the return-value burden and does so by naming the file format, location, and per-call naming convention. The mangled path notation and the absence of any note on what happens when the notebook has no chat history leave small gaps.

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

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

Schema coverage is 100% and the single 'notebook' parameter already documents that an id, URL, or partial title is accepted. The description only implies the notebook scope without adding format or resolution details, so the baseline 3 applies.

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

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

States a specific verb+resource: reads the ENTIRE chat history of a notebook and saves it to a Markdown file. This clearly separates it from notebook_perguntar/notebook_resposta (which query the chat) and from notebook_exportar. The scope word 'INTEIRO' makes the retrieval breadth unambiguous.

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

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

It implicitly and effectively positions itself against the query tools by stating 'Não pergunta nada ao NotebookLM e não gasta o limite de uso', which tells an agent this is the zero-cost way to obtain the transcript. It still lacks an explicit 'use this instead of X when Y' statement and does not clarify its relation to notebook_exportar or notebook_notas.

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 this is a non-readonly but non-destructive, open-world write. The description adds a genuinely non-obvious behavior: omitting the title causes Google to auto-name the notebook after the first source, which affects how an agent should treat the empty-title case. It omits auth requirements and whether the created notebook is returned.

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, zero padding, with the core action front-loaded and the optional-parameter caveat second. Every sentence 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?

For a one-optional-parameter creation tool with annotations covering the safety profile, the description covers the action and the title default. With no output schema, a hint about what is returned (e.g. the new notebook reference) would make it fully 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 coverage is 100% for the single 'titulo' parameter, so the baseline is 3. The description goes beyond the schema by explaining the consequence of omitting the parameter (Google auto-names it later), turning an optional field into a meaningful decision.

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: 'Cria um notebook novo no NotebookLM' tells the agent exactly what is produced. The word 'novo' separates it from mutation siblings like notebook_renomear or notebook_configurar_chat, though it does not name an alternative 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?

Usage is only implied: the agent must infer that a notebook should be created before adding sources (notebook_adicionar_fonte) or generating studio artifacts. No prerequisites such as an active login are mentioned, and no when-not-to-use condition 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?

Annotations already declare readOnlyHint=true and destructiveHint=false, so the safety profile is covered. The description adds useful context by specifying that results include estado, duração, id, and AI usage. It does not contradict the annotations and adds meaningful return-value detail beyond them.

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

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

The description is a single, front-loaded sentence with no redundant or filler text. It efficiently covers the action, the resource, the returned item types, and the extra AI usage 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?

Given a one-parameter read-only tool with full schema coverage and no output schema, the description is largely complete: it explains what is listed and which fields are returned. It only lacks sibling-routing guidance, which keeps it from being fully 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 100% and the single 'notebook' parameter is already documented as accepting id, URL, or partial title. The description adds no param-specific syntax or constraints beyond the schema, so the baseline 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 states a specific verb ('Lista') and resource ('o que já foi gerado no Estúdio do notebook'), and enumerates content types such as áudios, vídeos, slides and relatórios. It is clearly distinguishable from generation siblings like notebook_gerar_audio, though it does not explicitly name any sibling 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 description explains what the tool returns but gives no explicit guidance on when to use it versus alternatives such as notebook_estudio_status, notebook_estudio_baixar, notebook_estudio_excluir, or notebook_uso. Usage is only implied by the listing purpose.

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 (readOnly=false, destructive=false, openWorld=true) the description discloses the concrete side effect: files are always written to a fixed local path on this PC. It does not address overwrite semantics of the "(de novo)" re-download or any size/rate limits, so it stops short of full disclosure.

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

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

Two dense sentences: the capability and its scope come first, the destination-path constraint second. It earns nearly every clause, though the mixed "/app/%LOCALAPPDATA%\" path rendering is awkward and slightly hard to parse.

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

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

With no output schema, the description should cover what the call returns; it explains where files land but not whether the response contains paths, confirmations, or overwrite warnings. For a 3-parameter download tool with a mutation side effect, that leaves a meaningful 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%, so the baseline is 3. The description does add a little meaning by mapping artifact types to the item parameter and by naming the slide output formats that correspond to the baixar enum, but it gives no format guidance (e.g. pdf_pptx vs imagens).

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 ("Baixa (de novo)") plus the resource and enumerates exactly which Studio artifacts can be fetched (áudio, vídeo, slides, infográfico, relatório, mapa mental, cartões, teste, tabela). The word "já gerado" cleanly separates it from the notebook_gerar_* siblings, though it never names notebook_exportar or notebook_estudio as 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?

Usage is implied by "já gerado" (only call after the item exists) and by the pointer to notebook_estudio for ids, but there is no explicit when-to-use/when-not framing or comparison against notebook_exportar, which sounds like the nearest competing option.

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 destructiveHint=true, readOnlyHint=false and openWorldHint=true, so the safety profile is known; the description still adds two pieces of real value: the deletion is PERMANENT, and already-downloaded files on the PC are not affected. It does not describe what happens to the notebook or generated artifacts beyond the item itself, nor error/auth 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?

Three short sentences, the destructive scope is front-loaded with the permanence warning, and the type enumeration earns its space by defining exactly which artifacts qualify. No filler.

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

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

For a 3-parameter, no-output-schema deletion tool whose annotations already flag destructiveness, the description covers the essential unknowns: what gets deleted, that it is irreversible, and that local downloads survive. An agent has enough to call it correctly.

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

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

Schema coverage is 67%: 'item' and 'notebook' are documented in the schema (title-or-id, partial title, URL), but the required 'confirmar' boolean has no schema description. The description never mentions parameters, though 'PERMANENTEMENTE' plus 'Só use quando o usuário pedir' implicitly signals the confirmation gate for 'confirmar'.

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 ('Exclui') and resource (item do Estúdio), and enumerates the item types it covers (Resumo em Áudio, Mapa mental, Tabela de dados, etc.), which makes the scope unambiguous. It does not name the adjacent Studio siblings (notebook_estudio_renomear, notebook_estudio_baixar) to contrast with, 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?

'Só use quando o usuário pedir' gives an explicit gating condition for a destructive action, which is real usage guidance rather than an implied one. It does not name alternatives (e.g. rename instead of delete, or that downloading is non-destructive), so no when-not/alternative routing is provided.

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 readOnlyHint=false, destructiveHint=false and openWorldHint=true, so the safety profile is partly covered. The description adds nothing on top: it does not say whether the rename is reversible, what happens if the 'item' string matches multiple items, or whether generation state is affected.

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 short sentence with no waste, so it is concise, but the brevity is under-specification rather than efficiency — there is nothing front-loaded beyond the bare action.

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

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

This is a mutation tool with three required parameters, no output schema, and an open-world hint, yet the description never explains matching/ambiguity resolution or what the caller gets back. For a rename operation on generated Studio artifacts, an agent needs more than one sentence.

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 67%, and the one undocumented parameter is the most important new value: novo_titulo (with a maxLength of 300) has no description anywhere. The description also adds no semantics for 'item', which per the schema accepts a partial title or an id and could match ambiguously.

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 ('Muda o título') plus a scoped resource ('item do Estúdio'), which distinguishes it from notebook_renomear and notebook_fonte_renomear that target notebooks and sources rather than Studio items. It is clear what is changed but never says what a 'Studio item' is beyond the name.

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 use this versus notebook_renomear, notebook_fonte_renomear, or notebook_estudio. Nothing states prerequisites (e.g., the item must already exist or be finished generating) and no exclusions are given.

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

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

Annotations only say readOnlyHint=false and openWorldHint=true; the description adds the important behaviors: the call blocks/watts for a bounded time, it writes files to disk, and it names the exact output path. The one gap is that it doesn't say what the call returns when nothing finishes in time.

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 short sentences, front-loaded with the core action, then the repetition rule, then the side effect. The mixed path form '/app/%LOCALAPPDATA%\...' is slightly awkward but conveys the destination compactly.

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-optional-param polling tool with no output schema, the description covers the wait behavior, the repeat-until-done loop, and the file destination. Return-value semantics on timeout are the only missing piece an agent would want.

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 optional 'lote' parameter is fully documented in the schema itself. The description never mentions 'lote' or the fallback-to-all-pending behavior, so it adds nothing beyond the schema — baseline 3.

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: it monitors pending Studio items, waits within the call's time budget, and downloads what finishes. That scope separates it from notebook_estudio_baixar and notebook_estudio without naming them explicitly, so an agent can infer the distinction but gets no confirmation.

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?

'Repita até não sobrar nada pendente' gives a concrete polling loop, which is genuine usage guidance. However it never states when to prefer this over the sibling download/generate tools, nor what to do if the call times out with items still pending.

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 destructiveHint=true, but the description adds the detail annotations cannot: exactly what is destroyed (sources, chat, notes, Studio items) and that the effect is permanent and irreversible. It also states the confirmation gate the agent must enforce 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 sentences, both earning their place: the first carries the destructive scope, the second carries the guard condition. The irreversible nature is front-loaded via 'PERMANENTEMENTE'.

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 destructive, open-world mutation with no output schema, the agent needs the blast radius and the safety condition, and both are present. Nothing required to call it correctly 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%, so the schema already documents that 'notebook' accepts an id/URL/partial title and that 'confirmar' must be true. The description reinforces the intent behind 'confirmar' but adds no syntax or identifier-resolution detail beyond it. 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 (excluir) and resource (notebook) and immediately scopes what the deletion covers: 'com fontes, chat, notas e itens do Estúdio'. That cascade detail is what separates it from siblings like notebook_nota_excluir, notebook_fonte_remover and notebook_estudio_excluir.

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 precondition: only when the user explicitly asks and confirms which notebook. It does not name alternative tools for partial deletion, but the cascade scope implicitly tells the agent that the sub-deletion tools are unnecessary for a full wipe.

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 readOnlyHint=false and openWorldHint=true, so the write/external-service nature is known. The description adds genuinely useful side effects beyond that — a NEW file is created in My Drive, and for slides the .pptx is uploaded and then sent to the Drive trash — plus timing expectations (~5-15 s vs ~40-60 s). It does not state permission/scope requirements or what happens if the Drive quota or auth fails.

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

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

Front-loaded with the core action and return value, then progressively adds per-type detail; nearly every clause earns its place (timings, retry semantics, new-file warning). The parenthetical slide pipeline is dense but is the one place deep detail is warranted.

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 3-parameter tool with no output schema, the description supplies the return value (a Drive link), the supported/unsupported item matrix, cost in time, side effects, and idempotent retry behavior. An agent has everything needed to call it correctly once.

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 destino enum already documents the three values, their defaults per item type, and the 'só slides' restriction. The description's per-type destination mapping largely restates that, adding little new parameter meaning beyond the schema baseline.

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

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

States a specific verb+resource: exports an already-generated Studio item to the account's Google Drive and returns the link, with per-item-type destination mapping. It implicitly separates itself from the notebook_gerar_* family (it exports, it does not generate), but never names the closest sibling notebook_estudio_baixar, so the agent must infer why it would pick Drive export over a local download.

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 what can be exported and, more valuably, what cannot (interactive report, audio, video, map, cards, quiz have no Google export), which prevents misinvocation. It also gives a concrete retry rule for the 'in progress' slides case and warns against repeating exports without user request.

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 readOnlyHint=true, destructiveHint=false and openWorldHint=true, so the safety profile is covered. The description adds real behavioral value beyond that: it discloses the data's provenance (text NotebookLM extracted from notebook sources) and carries a prompt-injection warning to treat the content as information, not instructions.

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: the first defines the payload, the second delivers the security caveat. Nothing is wasted and the core purpose is front-loaded.

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

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

With no output schema, the description usefully says what comes back (full text plus optional guide). Combined with 100% schema coverage and full annotations, an agent has what it needs, though it could note truncation behavior tied to max_caracteres.

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 all four parameters (notebook, fonte, guia, max_caracteres) are already documented. The description echoes the guide concept (summary and topics) but adds no syntax or format detail beyond the schema, so the baseline applies.

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

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

States a specific verb+resource combo — reads the full extracted text of a source plus its guide (summary and topics). This clearly distinguishes it from the sibling listing tool notebook_fontes, though it never names an alternative 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 explains what the tool returns but never states when to choose it over notebook_fontes, notebook_pesquisar_fontes, or notebook_perguntar. Usage must be inferred from the verb 'lê'.

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 destructiveHint=true and readOnlyHint=false, so the description's job is to add context, which it does by emphasizing permanence and requiring user confirmation. It adds a bit of value on top of the safety profile the annotations already carry, but does not go further into irreversibility or downstream effects.

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

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

Two short sentences with zero waste, and the critical constraint (permanence) is front-loaded ahead of the usage rule.

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

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

The tool's safety profile is already covered by annotations, and the confirmation sweep is enforced by the schema's confirmar const:true. The description supplies the permanence warning and usage gate, leaving only minor gaps (such as what happens to derived artifacts) for this destructive operation.

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 all three parameters (fontes, notebook, confirmar) are already documented in the schema with const/true constraints. The description only implies that confirming which sources matters and adds no syntax or format detail beyond what the schema provides; baseline 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?

States a specific verb and resource (remove sources from a notebook) plus a strong consequence adverb (PERMANENTEMENTE), which makes the effect unmistakable. It does not explicitly distinguish itself from sibling notebook_excluir or notebook_fonte_renomear, so it stops short of 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?

"Só use quando o usuário pedir e confirmar quais" gives a clear precondition for invocation (explicit user request plus confirmation of which sources). It does not name an alternative tool or describe when not to use it versus siblings, so it is not a 5.

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 readOnlyHint=false and destructiveHint=false, so the mutation profile is known, but the description adds nothing beyond that: it does not say whether partial-title matches can rename the wrong source, whether titles must be unique within the notebook, or what is returned on success.

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

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

A single efficient sentence with the resource front-loaded and no waste, though its brevity leaves little room for the operational context an agent would need.

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

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

For a three-parameter mutation tool with no output schema, the description leaves the agent guessing about ambiguity handling for partial titles, whether the source's other properties (citations, indices) survive the rename, and what the call returns.

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 67%; the schema explains that 'fonte' accepts the current title, a partial title, or an id, and that 'notebook' accepts an id, URL, or partial title. The description only implies that 'novo_nome' is the replacement title and adds no details on the partial-match or length constraints already in 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?

The description states a specific verb+resource pair ("Muda o nome de uma fonte do notebook"), which pinpoints the rename operation on a notebook source rather than on the notebook itself. This implicitly separates it from notebook_renomear and notebook_estudio_renomear, though it never names those siblings 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 no guidance on when to use this tool versus notebook_renomear, notebook_estudio_renomear, or notebook_fonte_remover, and states no prerequisites such as needing the source to already exist or confirming an ambiguous partial-title match.

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 readOnlyHint=true, destructiveHint=false and openWorldHint=true, so the safety profile is covered. The description adds genuinely new context by enumerating the fields returned (type, size, state, link), useful since no output schema exists. It says nothing about ordering, pagination, or behavior for a notebook with zero sources.

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, front-loaded with the verb and resource, with the returned-field list appended efficiently. Nothing is padded, though the parenthetical type enumeration is slightly verbose.

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 read-only list tool with no output schema, describing the returned fields closes the main information gap, and annotations cover safety. Missing only minor operational details (ordering, empty-result behavior) that an agent could discover on first call.

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

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

Schema description coverage is 100% — the single parameter already documents that an id, URL, or partial title is accepted. The description adds no further parameter semantics, so the baseline 3 applies.

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

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

States a specific verb+resource ("Lista as fontes do notebook") and enumerates the returned attributes (tipo, tamanho, estado, link). An agent can tell it apart from notebook_listar and notebook_fonte_ler, though the description never names those siblings 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?

There is no when-to-use guidance, no mention of prerequisites (notebook must exist / have sources), and no routing to alternatives such as notebook_pesquisar_fontes for searching or notebook_fonte_ler for a single source's content. Usage is only inferable from the name.

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 declare non-read-only, open-world, non-destructive; the description adds the crucial async/polling behavior, expected duration, per-client timeout difference, and where files land. That is genuine value beyond the annotations, though the destination string '/app/%LOCALAPPDATA%\mcp-google/saidas/notebooklm neste PC' mixes incompatible path formats and is ambiguous about the real output path.

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

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

Front-loaded with the core action and duration, then the client-specific polling caveat, then the output location. Each sentence carries operational value, though the final path sentence is garbled and costs clarity rather than adding it.

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 7-parameter, long-running generation tool with no output schema, the description covers timing, async polling and file destination, which are the main unknowns. It omits cost/credit implications referenced indirectly by 'uso_maximo'/'notebook_uso' and whether an existing artifact is overwritten.

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% with two enums already documented inline, so the schema carries the parameter burden. The description adds no parameter-level meaning (e.g. how 'uso_maximo' interacts with notebook_uso, or that 'fontes' defaults to all), 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 concrete verb and artifact: generates an Audio Summary (AI-hosted podcast) from the sources and saves the .m4a. This cleanly separates it from siblings like notebook_gerar_video, notebook_gerar_slides or notebook_gerar_relatorio, which produce different media from the same sources.

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

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

Gives explicit operational guidance: the call takes ~3-6 min, on Claude Desktop it usually returns 'still generating' and you must poll notebook_estudio_status, while on Claude Code it blocks. It never explicitly excludes alternatives (e.g. when to prefer video or slides instead), so it stops short of full alternative routing.

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

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

Annotations already signal a non-read-only, non-destructive, open-world write. The description adds real value beyond them: it discloses the exact output location (/app/%LOCALAPPDATA%\mcp-google/saidas/notebooklm), that files are saved as both .md and .csv (Anki-importable), and that front/back is returned inline. These are concrete side-effect details the annotations cannot convey.

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 with the core action and side effects front-loaded; nothing is padded. The path string is somewhat noisy but it carries necessary information about where files land.

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 generation tool with 100% schema coverage and no output schema, the description covers what is produced (front/back), where files go, and import compatibility. Only the sibling routing and any permission/auth prerequisites are left implicit.

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 all seven parameters (foco, fontes, idioma, notebook, quantidade, uso_maximo, dificuldade) are already documented in the schema. The description adds no parameter-level meaning, so the baseline 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?

States a specific verb (gera) and resource (cartões didáticos/flashcards), plus what it produces (frente/verso) and side effects (.md/.csv files). The resource is distinct enough from siblings like notebook_gerar_teste or notebook_gerar_relatorio that an agent can pick it, though it does not explicitly name the 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?

There is no explicit when-to-use guidance or comparison to alternatives such as notebook_gerar_teste or notebook_gerar_relatorio. The usage is inferable from the resource name, but the description leaves 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.

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

Beyond the annotations (which only flag write + open-world), the description discloses the ~1-2 min latency, that a PNG file is written, and the exact fixed output directory — genuinely useful operational facts. It does not mention AI quota consumption even though the uso_maximo parameter implies metering.

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 the artifact, with no filler. The clause "com a descrição do conteúdo" is slightly ambiguous about whether a textual description is produced or consumed, which keeps it from a 5.

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

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

For an 8-parameter generation tool with no output schema, the description covers duration and file destination but leaves the return value (path? textual description? link) and the quota/uso_maximo relationship to notebook_uso unexplained. Adequate, but a caller still has open questions.

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% with 8 well-documented parameters including three enums, so the schema carries the semantics. The description adds nothing about parameters (foco, fontes, uso_maximo) and only indirectly signals the notebook_uso cross-reference through the schema itself.

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 ("Gera um infográfico") and adds the output form (PNG) and the approximate duration. It is distinguishable from siblings like notebook_gerar_slides or flow_gerar_imagem by naming the artifact, but it never explicitly contrasts with 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?

There is no statement of when to pick this over notebook_gerar_slides, notebook_gerar_mapa_mental, or flow_gerar_imagem, and no prerequisites (auth, notebook selection) are mentioned. The only contextual hint is the fixed output directory, which is about results, not usage.

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 the safety profile (readOnlyHint=false, destructiveHint=false, openWorldHint=true), and the description adds valuable context: a 10-30s runtime and the fact that artifacts are ALWAYS written to a fixed local path. It does not state permission or auth requirements, which keeps it short of 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 compact sentences that lead with the action and put the file-path caveat up front, with no filler. The Windows-style path with %LOCALAPPDATA% inside a POSIX-looking path is a bit confusing, but it is still brief.

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?

Without an output schema, the description carries the burden of defining the return, and it does (text tree plus saved .md/.json files), along with the timing and the fixed destination. For a five-parameter generation tool this is sufficient, though it could spell out what the returned tree contains or its size.

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 every parameter is already documented in the schema, making the baseline 3. The description adds nothing about params beyond reiterating the file path destination and making no reference to foco, idioma, or uso_maximo semantics.

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

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

States a specific verb and resource ("Gera um mapa mental das fontes") plus the output shape (tree returned as text, saved as .md/.json). It does not name which sibling studio generators it differs from, so an agent must infer the distinction from notebook_gerar_relatorio or notebook_gerar_infografico.

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 mention of "fontes" and the file destination implies the generation context, but there is no explicit when-to-use, when-not-to-use, or which sibling generator to pick instead. The recommendation for uso_maximo points at notebook_uso, a small piece of routing, but overall usage is inferred 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?

Annotations only say readOnlyHint=false and openWorldHint=true; the description adds genuinely useful behavior beyond that: a 30-90 s duration, the mapping of formato to file type, and the fact that files ALWAYS land in a fixed absolute path on this PC. It doesn't mention overwrite behavior for existing files, which is the remaining gap.

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

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

Front-loads the core behavior and latency in the first clause, then layers model and output-path detail. Dense but every sentence carries usable information; only the escaped-path string is slightly noisy.

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 7-parameter generation tool with an output schema absent but full schema coverage and annotations present, the description covers duration, artifact format, output location, and model requirements. What remains uncovered (behavior on repeated calls / overwrite) is minor.

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, and the description earns above that: it enumerates the modelo values, flags foco as mandatory for the 'Crie do zero' model, and clarifies what formato=documento vs interativo produces. This meaningfully enriches the modelo and formato parameters beyond their schema 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?

States a specific verb and resource ('Gera um relatório') plus concrete outputs (.md for documento, .html for interativo) and expected latency. It implicitly distinguishes itself from siblings like notebook_gerar_slides or notebook_gerar_audio by naming the report artifact, but never routes the agent explicitly against those siblings or notebook_exportar.

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

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

Provides operational context (which models exist, that 'Crie do zero' requires foco, that the error lists available models) but gives no explicit when-to-use / when-not-to-use guidance versus the many other generation tools. Usage is implied rather than directed.

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 declare readOnly=false, openWorld=true, destructive=false; the description adds the behavior that actually matters: the long 4-7 minute duration, the non-blocking partial response on Claude Desktop, the polling escape hatch, and the fixed output directory. It also discloses side effects (files written to disk, including .md text per slide) that the annotations do not capture.

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?

Four sentences, front-loaded with what is generated and then the runtime/async caveat, which is the highest-risk fact. The final path sentence is dense (with an odd %LOCALAPPDATA% fragment) but carries real information; nothing is 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?

With no output schema, the description still tells the agent what comes back (files, not inline content), where they land, how long it takes, and how to retrieve them when the call returns early. That covers everything needed to call the tool correctly and handle its result.

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

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

Schema description coverage is 100%, so every parameter including notebook, foco, baixar, fontes, idioma, duracao, formato and uso_maximo is already documented in the schema. The description adds no syntax or default detail beyond what is there, 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 ('Gera uma apresentação de slides a partir das fontes') and enumerates the artifacts produced (PDF/PPTX/imagens plus per-slide .md). It does not explicitly contrast itself with the many sibling generators (notebook_gerar_audio, _video, _infografico, _relatorio, etc.), so the agent must infer the choice from the resource name alone.

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

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

Gives concrete operational guidance: ~4-7 min runtime, and a precise branch — on Claude Desktop the reply comes back 'ainda gerando' and you must poll notebook_estudio_status until download, while on Claude Code the call blocks. It does not say when to prefer slides over the other studio artifact tools, but the async routing is explicit and names the correct sibling.

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 real behavior beyond the annotations: an expected ~30 s runtime, that output is returned as Markdown, and that .csv and .md files are also written to a fixed path. This is consistent with readOnlyHint=false and destructiveHint=false (file writes, no destruction). It stops short of describing what happens on generation failure or overwrite behavior of existing 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?

Two compact sentences: what it produces first, then where the artifacts land. Nothing redundant, and the most decision-relevant facts (output format, latency, save location) are front-loaded.

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

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

No output schema exists, yet the description tells the agent the return shape (Markdown) and the side files, plus the fixed output path and duration, which is enough to call it confidently. Minor gaps: no note on whether previous output files are overwritten and no behavior on long-running or failed generation.

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 each parameter is already documented in the schema, and the description adds no parameter-level detail (no clarification of 'foco' format, 'fontes' resolution, or the uso_maximo interaction beyond the schema text). Baseline 3 is appropriate when the schema does the heavy lifting.

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

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

States a specific verb and resource ('Gera uma tabela de dados a partir das fontes') and names the return format (Markdown) plus side artifacts (.csv and .md). This clearly distinguishes it from the other gerar_* siblings (audio, video, slides, mapa mental, relatorio, cartoes, teste, infografico).

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?

Implies usage context by saying the table is built from the notebook's sources and that all sources are used by default unless 'fontes' is passed, and it points to notebook_uso for the budget guard. However, it never states when to prefer this over notebook_gerar_relatorio or notebook_notas, nor any exclusion conditions.

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

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

Adds real behavioral context beyond the annotations: an estimated ~30 s runtime, the exact return payload, and the side effect of writing .md and .json files to a fixed path ('SEMPRE ... neste PC'). Annotations only cover readOnly/openWorld/destructive; the write behavior and latency disclosure are genuinely additive. It does not mention that the operation consumes the notebook's AI quota, which is the main hidden cost implied by the 'uso_maximo' parameter.

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 action and the returned payload, then the output-location constraint. No filler, and the emphasized 'SEMPRE' correctly flags the one surprising fact (fixed output path).

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?

Eight parameters with no output schema, so the description's enumeration of returned fields is valuable and mostly sufficient. The main remaining gap is that quota consumption (the reason 'uso_maximo' and notebook_uso exist) is not surfaced in the description for what is an openWorld, non-readOnly operation.

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% with enums documented for 'quantidade', 'dificuldade' and 'tipos_pergunta', so the schema carries the burden. The description adds no parameter-level detail such as defaults, constraints, or how 'fontes' interacts with 'foco'. Baseline 3 applies.

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

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

States a specific verb+resource ('Gera um teste') and immediately enumerates the payload (questões com alternativas, resposta certa, explicação, dica, gabarito) plus file output. It is clearly distinguishable from siblings like notebook_gerar_cartoes or notebook_gerar_relatorio by the 'teste/quiz' artifact, though it never names those siblings 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 no when-to-use, when-not-to-use, or alternative routing. The only pointer to a related tool (notebook_uso) lives in the schema for 'uso_maximo', not in the description itself. An agent must infer that this is the quiz-generation path from the wording alone.

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 say it is a non-destructive, open-world write; the description adds the expensive, long-running, sometimes-asynchronous nature and the exact output location. The async-vs-blocking distinction per client is precisely the kind of behavior annotations cannot express.

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?

Four dense sentences, front-loaded with what the tool produces before cost, latency, and polling behavior. Each sentence carries information, though the absolute file-path sentence is long and only marginally actionable given the tool reports the path anyway.

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

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

No output schema exists, and the description compensates by explaining that the .mp4 is saved to disk and that the immediate response may be 'ainda gerando' rather than the finished artifact. It does not describe the shape of the returned identifier/status object, leaving a small gap for an agent parsing the response.

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%, including enums for estilo and formato, so the schema already carries the parameter burden. The description adds nothing about parameters beyond the implicit link to notebook_uso via the usage budget, which is already stated in the schema. Baseline 3.

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: generates a 'Resumo em Vídeo (vídeo narrado com slides/ilustrações)' and saves the .mp4. Clear enough to act on, but it never contrasts itself with the adjacent siblings notebook_gerar_slides or flow_gerar_video, so the agent must infer which video generator 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?

Gives concrete operational context: ~5-20 min runtime on Google, ~9-11% of the usage limit, and an explicit platform-conditional follow-up ('no Claude Desktop... chame notebook_estudio_status até baixar'). That effectively tells the agent when extra polling is required. It stops short of saying when to prefer this over the other generation 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?

Annotations already declare readOnlyHint=true, destructiveHint=false and openWorldHint=true, so the safety profile is covered. The description adds value beyond them by disclosing what each listed item contains (id, título, data, número de fontes), which is meaningful since there is no output schema; it omits pagination, result caps, and auth requirements.

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

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

A single sentence with zero filler, front-loading the verb and resource and then the returned payload. Nothing in it is redundant with the title beyond the minimum needed to identify the resource.

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 no-param read-only list tool with no output schema, the description covers purpose and return fields well enough to call it correctly. Minor gaps remain around result volume/pagination and whether a login session is required first, which an agent might want to know before invoking.

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

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

The tool takes zero parameters and the schema is empty, so there is nothing for the description to disambiguate. Per the zero-parameter baseline, a 4 is appropriate; no parameter guidance is needed or missing.

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 ('Lista') and resource ('notebooks do NotebookLM (Gemini Notebook) do usuário'), and even enumerates the returned fields (id, título, data, número de fontes). It is clearly distinguishable from the many mutating siblings (notebook_criar, notebook_renomear, notebook_excluir), though it never names a 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?

Usage is only implied: a zero-parameter listing tool is naturally the entry point for discovering notebooks before calling notebook_fontes, notebook_perguntar, etc. However, the description states no when-to-use condition, no prerequisites (e.g., needing an authenticated session), and no alternatives.

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 the tool is a non-read-only, open-world, non-destructive write operation. The description adds useful context that converter_em_fonte lets chat and Studio use the content, but it does not explain whether conversion creates a new source, links the note, or has side effects.

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

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

The description is two compact sentences with no wasted wording. The core create operation is front-loaded, followed immediately by the optional conversion behavior.

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

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

For a simple create tool with annotations covering safety, the description is adequate but not complete. It explains the optional conversion purpose, yet omits duplicate handling, what conversion does to the created note, and how notebook resolution errors behave.

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 only 25%, so the description must help compensate. It names the title and text fields and explains the optional conversion effect, but it does not clarify notebook lookup behavior or the consequences of converter_em_fonte beyond its purpose, leaving some parameter semantics to the schema.

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

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

The description states a specific verb and resource: creating a note in a notebook, with title and text. It does not explicitly distinguish itself from siblings such as notebook_adicionar_fonte, but the resource is clear enough for an agent to identify the operation.

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: create a note, optionally converting it into a source for chat and Studio use. However, it does not state when to use this instead of notebook_adicionar_fonte or when conversion should be avoided, so guidance remains implicit.

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 destructiveHint=true and readOnlyHint=false, so the danger profile is machine-readable; the description reinforces this with 'PERMANENTEMENTE', which usefully stresses irreversibility. Beyond that it adds no context on permissions, cascade effects, or what happens if the note title matches multiple notes, and the required confirmar=true gate is explained only by the schema.

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

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

Two sentences, zero filler, with the destructive permanence warning front-loaded and the usage restriction immediately after. Nothing is redundant enough to cut.

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 destructive single-target tool with annotations covering the safety profile and no output schema, the description supplies the two things an agent most needs: irreversibility and user-consent gating. Only the resolution behavior for ambiguous note titles is left unaddressed.

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

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

Schema coverage is 67% and the schema itself explains that 'nota' accepts a title fragment or id and 'notebook' accepts id/URL/partial title. The description contributes nothing about these parameters, so it neither compensates for the undocumented 'confirmar' field nor clarifies ambiguity when partial titles match.

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 ('Exclui') plus resource ('uma nota do notebook') and a permanence qualifier, which lets an agent separate it from notebook_nota_criar and notebook_notas. It never explicitly names the sibling it is contrasted with (e.g. notebook_excluir for whole notebooks), so differentiation is implied rather than stated.

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

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

'Só use quando o usuário pedir' gives a concrete gating condition for invocation, which is meaningful for a destructive action. It stops short of naming alternatives or telling the agent what to do instead when the user has not explicitly asked (e.g. list notes first, or ask for confirmation).

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