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

The readOnlyHint annotation is consistent with the non-mutating 'List' verb, so there is no contradiction. The description adds modest context about the source ('mounted Drive') and completeness of the manifests, but it does not mention pagination, size limits, or what the returned manifests contain.

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, direct sentence with no filler. The action and object are front-loaded, and every word 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-parameter, read-only tool, the description is minimally adequate, but it leaves gaps: project semantics are undocumented, and there is no output schema to clarify the return format. The agent can invoke the tool but cannot fully predict how results will be shaped or 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?

The schema has 0% description coverage, and the description does not mention the 'project' parameter or how it affects the listing. An agent cannot tell whether project filters results, changes paths, or requires a specific value, so the description fails to compensate for the schema gap.

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

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

The description uses a specific verb ('List') with a specific resource ('complete checkpoint manifests') and location ('mounted Drive'), making the tool's purpose unambiguous. It is clearly distinct from sibling tools like restore_workspace or save_workspaces.

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

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

No guidance is provided about when to use this tool versus alternatives such as restore_workspace or save_workspaces. The description implies its use for listing manifests but does not state prerequisites, exclusions, or why an agent would choose it over a 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?

Annotations provide readOnlyHint=true, and the description adds meaningful behavioral detail beyond that: it reads only the manifest, not the corpus, and explicitly lists operations it does not perform. This is valuable transparency with no contradiction.

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

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

Three tight sentences, with the core purpose in the first line and the key limitations following. Every sentence adds useful information and the structure is easy to scan.

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

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

The description covers purpose, scope, and important non-behaviors, and references the training-script usage context. It lacks output/return details and parameter-specific guidance, but given the simple tool shape and read-only annotation, it is fairly complete.

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

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

Schema description coverage is 0%, so the description must compensate. It mentions manifest validation and cache sizing, but gives no explanation of cache_gib or reserve_gib semantics, units, limits, or how they interact. The parameter names alone are not enough.

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?

Description uses specific verbs and resources: 'Validate a local immutable shard manifest and size a bounded cache for large datasets.' It clearly distinguishes itself from sibling tools focused on runtime, workspace, and script execution.

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 clear context: it reads only the manifest and does not provision VMs or contact Drive. It stops short of naming an explicit alternative tool or a precise when-to-use versus when-not-to-use condition, but the exclusions are strong usage guidance.

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

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

There are no annotations, so the description bears full responsibility for disclosing behavior. It does state that the operation creates or restores, which implies state changes, but it does not explain conditions, side effects, whether existing state is overwritten, or what happens on a non-fresh VM.

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 compact sentence with no wasted words. It front-loads the main action, though its brevity contributes to the ambiguity rather than resolving 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?

The tool combines two distinct behaviors, has no annotations, no output schema, and overlaps with restore_workspace, but the description omits the conditions that govern create versus restore, the meaning of project, and the expected side effects. These gaps make it insufficient for reliable invocation.

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

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

With 0% schema description coverage, the description needed to explain how the project parameter influences the workspace or snapshot selection, but it never mentions project at all. The agent is left with only the schema title 'Project' and default value 'default', which provides minimal semantic grounding.

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

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

The description names a concrete operation: creating a managed workspace or restoring its Drive snapshot on a fresh VM. It is clear about the resource and action, but it does not differentiate itself from the sibling tool restore_workspace, which appears to overlap with the restore behavior.

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 'on a fresh VM' implies the intended scenario, but the description never explicitly says when to use this tool versus restore_workspace, save_workspaces, or start_runtime. It also gives no guidance on when the create path should be chosen over the restore path.

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

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

With no annotations, the description carries full burden. It discloses the refusing-overwrites behavior, which is valuable, but it omits what 'verified' means, what happens if the workspace is not empty, and any other side effects. The transparency is partial, not complete.

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 short, front-loaded sentences: the core action comes first, followed by the critical refusal behavior. Every word earns its place, with no redundancies or filler.

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

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

Given no annotations, no output schema, and 0% parameter description coverage, the description is too sparse for an agent to call the tool correctly. It lacks parameter semantics, return behavior, and edge-case handling (e.g., what happens if the workspace isn't empty or the checkpoint isn't verified).

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 description gives no explanation of the 'project' and 'snapshot' parameters, and the schema provides 0% coverage (no property descriptions). An agent cannot infer valid values or how these parameters affect restoration, so the description completely fails to compensate for the missing schema documentation.

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 clearly states the verb 'restore' and the resource 'verified Drive checkpoint' along with the target 'empty workspace'. It also mentions a distinct behavioral constraint ('Refuses overwrites') that helps differentiate it from siblings like save_workspaces or prepare_workspace.

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

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

The description implies usage (restore a checkpoint into an empty workspace) and includes a precondition, but it does not explicitly compare with alternatives like list_checkpoints or save_workspaces. There is no when-not-to-use guidance or condition for choosing this tool over siblings.

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

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

With no annotations, the description carries the full burden and delivers unusually rich disclosure: it covers restore/overwrite behavior, uploads, checkpointing, Drive flush, default shutdown, subprocess capabilities, persistence limits (workspace only, not RAM/credentials), and failure modes (Google termination, recoverable snapshots). This is exactly the side-effect and risk information an agent needs.

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?

All six sentences are information-dense and non-redundant, with the core purpose front-loaded and caveats organized logically. No filler or restatement of 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?

For a mutation tool with no annotations and no output schema, the description covers the full execution lifecycle, persistence, default side effects, and failure recovery. It is slightly incomplete regarding return values/log retrieval and the two unnamed parameters, but it is close to complete for safe invocation.

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

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

Schema description coverage is 0%, so the description must compensate. It implicitly documents script_path/source_directory via 'uploads the script (or... source directory)', checkpoint_seconds via 'periodically checkpoints', and stop_after via 'stops by default'. However, it never explains the 'arguments' parameter or the 'project' parameter, leaving two of six parameters semantically underspecified.

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 opening sentence names a precise action ('Run'), a specific artifact ('local Python script'), and a constrained target ('active, Drive-mounted GPU VM'). This clearly separates it from siblings like start_runtime, runtime_status, and save_workspaces, which cover VM lifecycle and workspace state rather than script execution.

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 'active... VM' establishes that the tool is for an already-running runtime rather than for starting one, and the lifecycle notes (checkpoint, flush, stop by default, long-running) give practical context. It stops short of explicitly naming sibling alternatives or stating when-not-to-use conditions, so it doesn't reach 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?

The annotations already declare readOnlyHint=true, so the safety profile is covered. The description adds a useful behavioral nuance ('without provisioning compute') and specifies what is checked, but it does not describe auth requirements, potential latency, or whether the mount must be pre-configured. This goes slightly beyond annotations but is not comprehensive.

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

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

A single, front-loaded sentence with no filler. It captures the core function, target resources, and the key non-effect efficiently, earning 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 zero-parameter read-only tool with annotations, the description is nearly sufficient. It names what is checked (runtime, Drive mount) and explicitly states no compute provisioning occurs. However, without an output schema, it does not mention what the result looks like (e.g., status summary, boolean, or error behavior), which could be useful but is not critical.

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 and schema coverage is 100%, so the baseline is 4. The description correctly implies there is nothing to supply and sets expectations that the tool only performs a read-only check. No additional parameter detail is needed.

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 clearly states a specific verb ('Check') and resource ('configured Colab runtime and Drive mount'), and explicitly distinguishes it from provisioning actions by adding 'without provisioning compute.' This differentiates it from start_runtime and others in the sibling list.

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

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

The phrase 'without provisioning compute' implies an appropriate use-case (status check without side effects), but it does not explicitly name alternatives like start_runtime or state when to use this over prepare_workspace. The guidance is implied rather than explicit.

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

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

Annotations provide destructiveHint=true, and the description goes beyond that by revealing specifics: the flush-required stop, the failure recovery (VM stays running on save failure), and the exclusion of unmanaged processes. It also discloses the refusal condition. This adds meaningful context without contradicting the annotation.

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

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

The description is three sentences with no wasted words. The primary action and condition lead, followed by scope limitations and failure/refusal behavior. Each sentence earns its place, and the structure is clean and 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?

For a destructive operation, the description covers all critical decision points: what it saves, when it stops, what it ignores, what happens on failure, and when it declines. No output schema exists, but the return value isn't essential for the agent's call decision. The description is complete for a zero-parameter tool with this complexity.

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

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

The tool has zero parameters and the schema describes 100% of them (none). The description doesn't need to explain parameters. Baseline of 4 for zero-parameter tools is appropriate; there is no missing parameter information.

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 — save all managed workspaces then stop the VM — and includes a necessary condition (Drive confirms flush). It explicitly distinguishes what it does not cover (unmanaged processes/files) and sets expectations about refusal. This clearly separates it from siblings like save_workspaces or runtime_status.

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

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

The description conveys when it is appropriate to call (when you want to save and stop) and when it will refuse (if managed jobs are active). However, it does not explicitly name alternatives such as save_workspaces for saving without stopping or runtime_status to check job activity. It gives sufficient context for an agent to infer, but stops short of explicit routing guidance.

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

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

With no annotations provided, the description carries the full burden of behavioral disclosure. It clearly states side effects (flushes Drive, unmounts it), state outcome (VM stays allocated), a refusal condition (managed jobs active), and a follow-up requirement (remount Drive). This is unusually transparent for a zero-parameter 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?

The description is concise and front-loaded with the primary action, followed by short sentences for state, guard condition, and post-condition. Every sentence adds distinct value and none are redundant.

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

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

For a tool with no parameters, no annotations, and no output schema, the description covers all essential context: what the tool does, what side effects it has, when it refuses, and what must happen afterward. An agent has enough information to select and invoke 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 has zero parameters, so there are no parameter semantics for the description to clarify. The baseline of 4 applies, and the description reinforces that the operation is fixed-scope and requires no input.

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

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

The description names a specific verb and resource: 'Checkpoint all managed workspaces, flush Drive, and unmount it.' It also states 'VM stays allocated,' which clearly separates this from sibling tools like safe_stop or restore_workspace. The operation is unambiguous and specific.

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 clear usage context: it refuses to run while managed jobs are active, which tells the agent when not to call it, and it warns to remount Drive before further persistence operations. It does not explicitly name alternatives or compare this tool with restore_workspace or safe_stop, so it falls just short of full guidance.

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

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

No annotations are provided, so the description must carry the full burden of behavioral disclosure. It discloses cost (Colab units) and the default GPU, which is useful, but omits other behaviors like idempotency, async behavior, or side effects beyond cost. For a provisioning tool, this is partial 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 sentences with zero waste. The core purpose and default are front-loaded, and the conditional instruction is necessary and concise.

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

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

The description covers the main action, default GPU, cost, and a prerequisite. It does not describe return values or how to verify success, but given the simplicity and lack of output schema, this is reasonably complete. It could mention whether it blocks or returns immediately, but overall it's adequate.

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

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

With 0% schema description coverage, the description must compensate. It mentions 'Default GPU is L4', which clarifies the default for the optional gpu parameter, but does not enumerate valid values or explain what null means beyond the default. An agent would not know what strings to pass (e.g., 'T4', 'A100').

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 'Provision or reuse' with the resource 'runtime', and mentions the default GPU and cost. This clearly distinguishes it from siblings like runtime_status (status check) and safe_stop (stop), so an agent can select it appropriately.

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 a clear conditional prerequisite (if drive_mounted is false, run a specific mount command) and mentions that it consumes Colab units. It does not explicitly name alternatives, but the action and context are clear enough to imply when to use it.

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