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

No annotations are provided, so the description carries the full burden. It discloses that leases can expire or mismatch and that replacements should not be followed, which are behavioral traits, but it doesn't explain what the lease is for, what 'pass it' means, or what side effects/return values to expect. The guidance is too cryptic to be useful.

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

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

The description is only two sentences and front-loads the core action ('Issue an operation lease'). Every word is purposeful, though the extreme brevity contributes to the overall lack of clarity.

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 appears to involve a time-sensitive lease mechanism, but the description does not explain what 'pass it immediately' entails, what lease expiry/mismatch means, or what 'replacement' refers to. With no annotations and no output schema, the description is insufficient for an agent to invoke the tool correctly and interpret 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?

The input schema provides descriptions for all three parameters (session, interval, observations) with 100% coverage, so the description adds no parameter-specific meaning. With high schema coverage, the baseline of 3 is appropriate.

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

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

The description states 'Issue an operation lease,' which is a specific verb and resource, but the concept of an operation lease is left undefined and the connection to allocation is not made explicit. It does not distinguish itself from sibling tools, as 'operation lease' is never contextualized within the colab toolset.

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 conditional instructions ('if expired/mismatched, probe again, never follow replacement') that imply a usage pattern, but it does not explain when to use this tool versus alternatives or what qualifies as expired/mismatched. Usage is implied through the protocol rather than explicitly stated.

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

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

No annotations are provided, so the description carries the full burden. It transparently discloses that the tool performs an explain-and-return-URL operation, implying read-only behavior with no side effects. It does not explicitly state 'no modifications are made,' but the phrasing strongly suggests an informational tool, which is sufficient for a zero-parameter utility.

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 concise sentence that covers both the explanation aspect and the return value. It is front-loaded with the primary purpose (explain) and the specific outcome (URL). Every word earns its place with no redundancy 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?

For a tool with no parameters, no output schema, and a simple informational purpose, the description is complete. It tells the agent what the tool does and what it returns. It could optionally mention that it requires no arguments, but the schema already makes this clear, so no significant gap exists.

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 already reflects this with 100% coverage. According to the rubric, a baseline of 4 is appropriate when there are no parameters to describe. The description adds no parameter information because none exists.

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 two specific actions: explain compute-unit visibility and return Google's official account-management URL. This is a specific verb+resource combination that distinguishes it from sibling tools, which are all focused on file operations, process management, or notebook execution rather than compute-unit information.

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 this tool should be used when a user needs information about compute-unit visibility or the account-management URL. However, it does not explicitly state when to use this tool versus alternatives, nor does it mention any exclusions. Usage context is mostly inferred from the tool name and description.

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 non-obvious fact that the operation doesn't consume GPU quota and is local, but it doesn't mention file-overwrite behavior, directory creation, or return values. Schema adds the 'never replaced' detail, but the description itself is thin.

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?

Single sentence, front-loaded with the verb and resource, no wasted words. It conveys the core purpose and a key side-effect efficiently.

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 create tool, the description covers the core purpose and a key side-effect (no GPU quota). It doesn't specify return behavior or prerequisites, but the simplicity mitigates that; it's reasonably 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 covers 100% of parameters with descriptions. The tool description adds no parameter-specific detail; it relies on the schema. Therefore baseline score of 3 applies.

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

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

The description uses a specific verb ('Create') and resource ('new local Colab-ready .ipynb notebook') and adds a distinguishing behavioral qualifier ('without consuming GPU quota'), clearly separating it from sibling tools like colab_upload or colab_execute_notebook.

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 (when you want a new local notebook) but provides no explicit guidance on alternatives or exclusions. Given the sibling list includes upload/download/execute, a sentence clarifying when to use this over other tools would improve clarity.

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 bears full responsibility for disclosing behavior. It mentions 'bounded, checksummed' which hints at transfer limits and integrity checks, but does not elaborate on what these mean operationally, nor does it mention permissions, side effects, failure modes, or return behavior. This is minimal disclosure at best.

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

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

The description is a single, front-loaded sentence that efficiently communicates the tool's identity as an alias. It contains no redundant or filler content, and every word contributes to the message, making it highly concise and well-structured.

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 has no annotations, no output schema, and a minimal description. The description fails to explain what the tool actually does, when to use it, its behavior, or any constraints. For a tool with only a name and a pointer to another tool, this is completely inadequate for an agent to understand its functionality and use it correctly.

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

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

The input schema provides 100% description coverage for all three parameters, so the baseline is 3. The description adds no additional parameter information beyond what the schema already includes, so it neither enhances nor detracts from the schema's clarity.

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 identifies the tool as a compatibility alias for colab_transfer_download, which suggests it performs the same function, but it never explicitly states that it downloads files. It's more than a tautology as it references a specific canonical tool and adds 'bounded, checksummed' characteristics, but the purpose remains vague without prior knowledge of colab_transfer_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?

The description provides no guidance on when to use this tool versus colab_transfer_download or other download-related tools. It only states it is a compatibility alias, leaving the agent to infer that it should be used as a drop-in replacement, but there is no explicit context, exclusions, or alternative recommendations.

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

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

No annotations are provided, so the description carries full burden. It discloses that execution is 'guarded' and that the timeout may be ambiguous, but lacks details on side effects, permission requirements, return behavior, or failure modes. This is insufficient for a code execution 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 a single concise sentence with information front-loaded: the primary purpose first, followed by a usage caveat. Every word serves a purpose, though it is quite terse for the complexity of the tool.

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 5 parameters, no annotations, and no output schema, the description needs to provide more operational context. It fails to explain session management, lease tokens, or expected output, making it incomplete for a tool of 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?

Schema coverage is 100% with each parameter described. The description adds a caveat about timeout ambiguity, which provides extra context for the timeout parameter, but it does not elaborate on session, lease_token, or output_limit beyond what the schema already provides.

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

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

The description specifies 'Execute guarded Python', clearly identifying the tool as a code execution operation with a resource (Python). It is specific enough to understand the core function, though it does not differentiate from similar siblings like colab_run_command or colab_execute_notebook.

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 explicitly recommends using durable process_start for long work, providing a clear exclusion criterion. It implies this tool is for shorter or interactive executions, but does not cover other alternative tools or specific conditions beyond timeout.

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 of behavioral disclosure. It mentions a failure-handling behavior (keep checkpoint, rerun) but does not disclose other impacts such as file overwriting, session management, or resource/rate limitations.

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 convey the core action and a failure-handling trait. However, the second sentence uses cryptic phrasing ('reacquire and rerun deliberately') that might confuse, though it remains 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 is minimal for a tool with 4 parameters and no output schema. It does not explain the return value, the relationship between source and output paths, or session semantics beyond what the schema already provides. Missing context that an agent needs to use it correctly.

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

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

The schema descriptions cover 100% of parameters. The tool description adds no additional semantic detail about the parameters, so it meets the baseline expected 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 clearly identifies the action (execute) and the resource (notebook cells), and the tool name 'notebook' distinguishes it from generic 'colab_execute' or 'colab_run_command'.

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 for executing notebook cells but provides no explicit guidance on when to prefer this over sibling tools like colab_execute, nor does it state exclusions or prerequisites such as session requirements.

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. It adds the behavioral warning about runtime replacement and unrecoverable old /content, which is useful context. However, it does not disclose what the tool actually returns (e.g., file names, full paths, pagination) or any potential side effects beyond the implied read-only nature.

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 extremely concise: two short sentences with no fluff. The primary purpose is front-loaded in the first sentence, and the second adds a critical caveat. 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 simple list tool with fully documented parameters and no output schema, the description provides adequate purpose and a relevant runtime lifecycle warning. However, it lacks clarity about the return format and could more explicitly state that it lists files/directories under the given path. The caveat about reacquisition is contextually relevant but somewhat cryptic.

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 baseline is 3. The description does not add any parameter-specific information beyond what the schema already provides. It only references /content in the caveat, which is already the default value 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 'List runtime paths' clearly identifies the action (list) and the resource (runtime paths), and it distinguishes this tool from siblings like colab_fs_read, colab_fs_write, and colab_fs_stat. However, 'runtime paths' is slightly ambiguous and could be more explicit about listing directory contents.

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 provides no explicit guidance on when to use this tool versus alternatives. It mentions a runtime_replaced/missing caveat, but this is more of a behavioral warning than usage guidance. No alternatives are referenced, and no conditions for use are stated.

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

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

With no annotations provided, the description carries the full burden for behavioral disclosure. It does not mention that the tool may create missing ancestors (parents defaults true), that an existing directory is accepted by default (exist_ok true), or any error scenarios. It only hints at idempotency with exist_ok but fails to explain default behavior or side effects, making it inadequate for a mutation 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 exceptionally concise with two sentences that are front-loaded with the core purpose and then a focused usage tip. Every word earns its place; no filler or redundancy.

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

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

Despite the schema covering all parameters, the tool is a mutation with no annotations and no output schema. The description does not provide a complete behavioral picture—missing the recursive creation behavior (parents), default tolerance for existing paths (exist_ok), and the /content confinement context. The hint about ambiguous responses suggests complexity that is not adequately addressed.

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 baseline is 3. The description adds value by connecting exist_ok to 'idempotent retry on ambiguous responses', giving a practical usage rationale that goes beyond the schema's simple 'True accepts an existing directory'. This is a meaningful semantic addition for a parameter.

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

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

The description clearly states the action ('Create') and the resource ('a runtime directory'), which is specific and immediately distinguishes it from sibling FS operations like read, write, remove, and list. The verb-object form is unambiguous and accurately reflects the tool's function.

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 tool versus alternatives. The mention of exist_ok for idempotent retry is a parameter-level hint, not a tool-selection guideline. No context is provided about preferred scenarios, prerequisites, or cases where a different sibling tool should 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?

With no annotations provided, the description carries the burden of behavioral disclosure. It adds a valuable note about checking source/destination after response loss before retrying, implying non-idempotency and a need for verification. However, it doesn't mention other behavioral traits like permissions, atomicity, or whether the operation is destructive to the source (beyond what 'move' implies).

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 extremely concise: two short sentences. The first states the core action, and the second provides a targeted safety tip. No wasted words, front-loaded purpose.

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 move operation with fully described parameters, the description is minimally viable. It doesn't explain return values (no output schema exists), but the schema covers paths and overwrite behavior. The retry note adds helpful context, yet the description could be more complete by explicitly stating the effect (e.g., source is removed) or typical use cases.

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

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

Schema description coverage is 100%, so the schema already documents all four parameters (source, destination, session, overwrite) with clear descriptions. The tool description adds nothing beyond the schema, so the baseline score of 3 applies.

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

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

The description clearly states the action ('Move a path') with a specific verb and resource, distinguishing it from sibling filesystem tools like colab_fs_list, colab_fs_stat, and colab_fs_remove. No other tool in the list performs a move, so the purpose is 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?

The description offers no guidance on when to use this tool versus alternatives (e.g., when to use move instead of read/write or transfer tools). The only usage-related note is about verifying state after response loss, which is a safety tip, not a comparison with 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?

With no annotations, the description must disclose behavior, but it only mentions offset and incarnation handling. It does not explain return format (e.g., base64, next_offset), error behavior, or session concurrency rules, leaving significant behavioral gaps.

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 extremely concise at two sentences, with the purpose front-loaded and the usage guidance following. Every word contributes meaning, with no redundancy 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 the lack of annotations and output schema, the description leaves out important context like the base64 return encoding, the presence of next_offset in responses, and detailed session behavior. It is minimally complete with the schema filling in parameter details, but not fully self-sufficient.

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

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

Schema coverage is 100%, so the schema already fully describes all parameters (path, limit, offset, session). The description adds no extra parameter semantics beyond implying a chunked read, which is adequate given the 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 'Read a chunk,' which clearly indicates a read operation on a file resource, supported by the 'path' parameter. It differentiates from sibling tools like colab_fs_write and colab_fs_list by specifying a chunked read, though it does not explicitly name the resource as 'file'.

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 instruction 'Keep next_offset; after incarnation change restart from restored source' provides clear guidance on how to use the tool for sequential reads and how to handle session changes. It does not explicitly compare to alternatives, but the context is sufficient for a read operation.

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 disclosing destructive behavior. It implies permanence by instructing to stat after response loss, but does not explicitly state that the operation is irreversible or what side effects occur (e.g., non-empty directory requires recursive flag). The guidance is useful but not a complete disclosure of behavioral traits.

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 deliver essential operational guidance without any filler. Every word contributes to the intended usage, making it highly concise and well-structured.

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

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

The tool is a destructive operation with no output schema, so the description should explain what the user can expect on success/failure. It omits return value information and does not mention that recursive is needed for directories (though schema covers that). The stat-first advice helps, but the description leaves gaps about error handling and outcome confirmation.

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 covers 100% of parameters with descriptions, so the baseline is 3. The description adds value by explicitly tying missing_ok to idempotent cleanup and suggesting stat-first behavior, which enhances understanding of when to set that parameter beyond the mere 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?

The description 'Remove explicitly' clearly indicates the core action (remove) and resource (file system), but is vague about what exactly can be removed (files, directories, both). It does not distinguish itself from sibling tools like colab_fs_move or colab_fs_mkdir, relying on the tool name for specificity.

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 clear context on when to use missing_ok for idempotent cleanup and advises running stat first after response loss, which is a safety check. However, it does not explicitly state when this tool should be chosen over alternatives or when not to use it, so it misses the full exclusion 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 burden of behavioral disclosure. It adds a valuable non-obvious trait: a missing path may be due to reclamation, not just non-existence, and recommends verifying the session fingerprint first. This goes beyond what the schema states and helps the agent avoid misinterpreting results. It does not describe return format or side effects, but the tool is clearly read-only in nature from the name.

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 sentences long, with the primary purpose front-loaded. Every word adds value: the first sentence states the action, the second provides a critical caution. There is no fluff or repetition.

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

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

Given the tool's simplicity and the absence of an output schema, the description is nearly complete. It names the operation and warns about a key edge case (reclamation). It does not explicitly state the return format (e.g., metadata fields), but the term 'stat' conventionally implies metadata. The warning about session fingerprint adds essential operational context that compensates for the missing output schema.

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

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

Schema description coverage is 100%, and each parameter (path, session, checksum) has a clear description. The tool description adds no additional parameter-level detail, so the baseline score of 3 is appropriate. The schema already explains path confinement, session rules, and the checksum boolean.

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 tool's function with a specific verb and resource: 'Stat/checksum a path.' This distinguishes it from siblings like colab_fs_list (which lists directory contents) and colab_fs_read (which reads file content). The use of 'stat' and 'checksum' unambiguously signals metadata retrieval and integrity checking.

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 second sentence provides important context: 'Missing may mean reclamation; verify the session fingerprint first.' This advises the agent on how to interpret a missing path and emphasizes verifying session identity before concluding. However, it does not explicitly mention alternative tools or when not to use this tool, so it falls short of 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?

With no annotations, the description carries the burden of disclosure. It does provide a non-obvious behavioral caveat about append retries not being idempotent and advising a stat before retry. However, it omits other relevant traits like atomicity details (though schema covers replace/append) and does not mention permission requirements or failure behavior.

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

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

Extremely concise: two sentences with no filler. The key action is front-loaded, and the retry warning is an efficient addition that 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?

Given the moderate complexity (5 params, no output schema, no annotations), the description is minimal but not fully complete. It provides a useful retry caution, yet lacks usage guidance and fails to mention what happens on success/failure, leaving the agent to infer from schema and sibling context.

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 fully documents all five parameters. The description adds minimal parameter meaning beyond the schema; 'small chunk' hints at size limits, but the schema already states the 1,000,000-byte cap for data_base64.

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 the action ('Write') and resource ('a small chunk'), clearly indicating a file write operation. It distinguishes from siblings like colab_fs_read and colab_fs_list by focusing on writing, though 'chunk' is slightly vague and could imply partial writes.

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

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

No explicit guidance on when to use this tool versus alternatives such as colab_upload or colab_fs_move. The retry warning implies a write scenario, but there is no mention of preferred use cases or exclusions.

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

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

With no annotations provided, the description carries the full burden. It explicitly discloses the key behavioral trait that no runtime is started, which is useful. However, it does not explain what 'report' returns, whether it has side effects, or how authentication readiness is determined, leaving some behavioral ambiguity.

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, tightly worded sentence that immediately states the action and key constraint. No filler or redundant phrasing is present.

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

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

The tool is simple (no parameters, no output schema), but because there is no output schema, the description should ideally indicate what the report contains (e.g., boolean, status object). It does not, leaving the agent unaware of the return format. Still, the core purpose and non-invasive nature are covered.

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 the baseline is 4. The description correctly adds no parameter-specific information, and there is no schema to complement. It is appropriately silent on parameters.

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 the specific verb 'Report' and identifies the resource as 'authentication readiness', clearly distinguishing this from sibling tools like colab_start or colab_process_start. The qualifier 'without starting a runtime' adds a distinguishing scope that makes the tool's purpose 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?

The phrase 'without starting a runtime' implies this is a safe, lightweight pre-flight check that can be used before heavier operations like colab_start or colab_process_start. However, it does not explicitly name alternatives or state when not to use it, so it falls just short of full explicit 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 carries the burden. It discloses a specific behavioral trait: 'On incarnation error, discard results and reacquire,' which gives some insight into error recovery. However, it does not explain the return value, side effects, or any resource requirements, leaving significant gaps.

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 brief and front-loaded with no wasted words. However, the second sentence is cryptic and might sacrifice clarity for brevity, but it remains efficient in length.

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

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

Given the absence of an output schema and annotations, the description is insufficiently complete. It does not explain what 'runtime resources' includes, the format of results, or how the parameters affect the inspection. The error-handling note is present but lacks context.

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 baseline is 3. The description does not add any meaning to the parameters (tools, session, process_limit) beyond what the schema already provides, so it neither enhances nor detracts from parameter understanding.

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 'Inspect runtime resources' with a clear verb and resource, but 'runtime resources' is broad and ambiguous, especially given sibling tools like colab_process_list, colab_sessions, and colab_health. It does not specify what exactly is inspected or how it differs from related tools.

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

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

The description provides no guidance on when to use this tool versus alternatives. It only gives a high-level action and an error-handling note, with no mention of use cases, prerequisites, or situations where this tool is preferred.

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 of behavioral disclosure. It states a critical limitation (cannot prevent reclamation) and advises to 'start and restore' on loss, which is useful context. It omits details like response format or side effects, but for a simple heartbeat tool this is solid.

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 core action, zero waste. The second sentence adds an important caveat and recovery hint without verbosity.

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 2-param tool with no output schema, the description covers purpose, limitation, and a recovery hint. It does not explicitly tie parameters to behavior, but the schema handles that, and the phrase 'start and restore' is slightly ambiguous, preventing a 5.

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 both parameters already have clear descriptions. The tool description adds no parameter-specific semantics, so the baseline score of 3 is appropriate.

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

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

The description uses a specific verb 'Report/refresh' and resource 'heartbeat', clearly distinguishing it from sibling tools like colab_health and colab_sessions. The caveat 'cannot prevent reclamation' adds further purpose specificity by stating what the tool does not do.

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 clear context for when to use the tool (to report or refresh a heartbeat) and a key exclusion ('cannot prevent reclamation'). It does not explicitly name alternative tools, but the limitation helps the agent understand this is not a reclamation-prevention tool, offering implicit 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 indicates a read-only listing operation, but does not explicitly state it is safe, mention authentication needs, rate limits, or what 'checkpoints' entails. The description is too terse to fully inform the agent about the tool's 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?

The description is a single, front-loaded sentence with no wasted words. Every part contributes to meaning, making it highly efficient.

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

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

Given the tool's simple nature (zero parameters, output schema present), the description is adequately complete for identifying what the tool returns. It could add a bit more context about what a 'checkpoint' is, but the output schema likely covers return values.

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 are zero parameters, so the baseline is 4. The description needs no parameter information, and the input schema is already empty, providing full 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 'List notebook checkpoints whose GPU runtimes were released' uses the specific verb 'List' with a clear resource ('notebook checkpoints') and a distinguishing qualifier ('GPU runtimes were released'). This clearly separates it from sibling tools like colab_sessions or colab_process_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 description clearly implies the intended use case: to find notebooks that were paused due to GPU runtime release. It does not explicitly name alternatives or exclusions, but the context is sufficiently clear among the sibling tools.

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

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

With no annotations, the description carries the transparency burden. It discloses a key destructive behavior: '/content is lost.' It also indicates the sequence of actions ('checkpoint locally then release'). But it does not mention whether the session is terminated, if it can be resumed, or any permission or rate-limit implications.

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 extremely concise—just two short sentences. Both carry meaningful information: the action and a critical data-loss warning. No filler or redundancy.

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

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

The description provides the essential purpose and a critical caution, but omits details such as what 'checkpoint locally' concretely saves, whether the session is destroyed or simply paused, and how it differs from colab_stop. Given the absence of output schema and annotations, the description is minimally viable but not 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?

The input schema provides descriptions for both parameters (session and notebook_path) with 100% coverage. The description does not add additional parameter-level details beyond what the schema already states, so the baseline score of 3 is appropriate.

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

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

The description states a clear action: 'Checkpoint locally then release.' This indicates a pause/save-and-release behavior, and the warning about /content loss provides scope. However, it does not explicitly name the tool's action as 'pause', relying on the name itself.

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

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

The description gives a usage prerequisite: 'Transfer non-notebook artifacts first; /content is lost.' This implies when to use the tool (before losing data) and warns about the consequence. However, it does not explicitly compare to alternatives like colab_stop or colab_keepalive, or state when to choose this over those.

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?

In the absence of annotations, the description does disclose some behavioral traits: atomicity and failure behavior (holding runtime/stage and retry capability). However, it omits side effects, permissions, or what happens on success, so it only partially carries the transparency burden.

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 very short (two sentences), which is concise but at the expense of clarity. It is front-loaded with 'Export', but the first sentence is vague and the overall structure lacks essential context.

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

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

Given the tool's complexity (12 parameters, no output schema, no annotations), the description is incomplete. It does not explain what is exported, how remote_path/local_path relate, or what the result/return is. The sparse description is insufficient for a tool of this scope.

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 12 parameters are documented in the input schema. The description adds nothing about parameters, but this is acceptable because the schema already provides thorough meaning.

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

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

The description says 'Export atomically' but never states what resource is being exported or what operation it performs beyond the name. It does not distinguish from sibling tools like colab_process_export_cleanup or colab_transfer_download, making the purpose vague and close to a tautology.

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 tool versus alternatives. The only usage-related note is about failure recovery ('retry same call from recoverable_export'), but it does not explain use cases, prerequisites, or when not to use 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?

No annotations are provided, so the description carries the full burden. It discloses that 'remote artifacts are unchanged,' which is helpful behavioral insight. However, it does not explain what 'discard' means in terms of local state or whether this operation is destructive to local files/processes, leaving some ambiguity.

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 extremely concise: two short sentences that front-load the core purpose and usage condition. Every word earns its place, with no fluff or redundancy.

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

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

For a simple cleanup tool, the description covers the essential context: when to use it and that remote artifacts are untouched. It doesn't detail return values or exact local effects, but given the lack of output schema and the tool's likely simple nature, it is reasonably 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?

The schema description coverage is 100%, so the baseline is 3. The description adds no parameter-specific meaning beyond what the schema already provides. It references the 'failed export stage' but doesn't clarify how the parameters (process_id, remote_path, local_path, session) relate to this discard operation.

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 ('Discard') and identifies the exact resource ('failed export stage'). It clearly communicates the tool's purpose and distinguishes it from sibling tools like colab_process_export or colab_transfer_cleanup by focusing on the failed export scenario.

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 provides an explicit condition: 'Use only after abandoning retry'. This clearly states when the tool is appropriate. It doesn't name alternative tools explicitly, but the condition implies that this is for a specific failure state, which is sufficient guidance for an agent.

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

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

No annotations are provided, so the description carries the full burden. It explicitly states the read-only nature via the verb 'list' and adds context about persistence and ownership. It does not disclose edge cases like session disambiguation, but that is subtle and covered by the schema, making this a sufficiently transparent description for a list 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?

The description is only two sentences: one stating the core action and resource, the other explaining when it is useful. Every word contributes meaning, with no redundancy 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 the low complexity (single optional parameter, existing output schema), the description provides sufficient context for an agent to understand when and why to invoke the tool. It explicitly ties the operation to the restart recovery workflow and indicates the kind of information obtainable (IDs and export 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 input schema fully describes the single parameter 'session,' including the null behavior when exactly one session exists. The tool description adds no parameter-specific information beyond the schema, so the baseline score of 3 applies per the rubric 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 opens with the specific verb 'List' and clearly identifies the resource as 'persisted owned processes,' which distinguishes it from sibling tools that act on individual processes (e.g., colab_process_status, colab_process_output). The added context about recovering IDs and export state further clarifies its purpose.

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 provides an explicit use case: 'After restart, use this to recover IDs and export state.' This gives clear context for when to use the tool. However, it does not explicitly mention when not to use it or name alternatives, so it falls short of 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?

No annotations are provided, so the description carries the disclosure burden. It adds useful behavioral context: output is retained in a local spool, pagination via next_offset is required, and the spool survives runtime loss. It does not mention side effects (though 'read' implies non-destructive) or error cases, but the key durability and pagination behaviors are 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?

Two short, front-loaded sentences. The first gives the core action; the second provides essential stateful guidance. No wasted words, efficient and clear.

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 output schema, the description should explain return values. It hints at next_offset being returned but does not describe the content format, stream handling nuances, or how errors manifest. For a paginated read with five parameters, more detail would improve completeness, though the schema covers parameter meanings.

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 baseline is 3. The description reinforces the offset behavior with 'Keep next_offset' but does not add new details beyond the schema, which already explains the offset semantics and process_id requirement.

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 tool reads retained output, with a specific verb (read) and resource (retained output). It distinguishes the operation from process management tools like colab_process_status or colab_process_export, though it does not explicitly name alternatives. The purpose is unambiguous and aligned with the tool 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?

The use case is implied: reading retained process output. The note about runtime loss provides a specific scenario where the tool remains useful, giving some contextual guidance. However, it does not explicitly contrast with alternatives like colab_process_export or when not to use this tool, so guidance is limited.

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

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

With no annotations, the description must carry the burden of disclosing behavioral traits. It does disclose key safety behavior: never signaling a replacement and falling back to status inspection for exited/lost processes. However, it does not mention the destructive nature of KILL, process-group signaling, or ownership verification beyond the word 'owned.' The schema adds some of this, but the description could better disclose error handling and 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 extremely concise: two sentences, 17 words, with the main action front-loaded ('Signal an owned process'). The second sentence adds a critical conditional and warning without redundancy. Every word contributes meaningful information, and it is well-structured for quick parsing.

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/process-control tool with no output schema, the description covers essential context: ownership, the no-replacement safety rule, and the exit/lost fallback. Combined with the comprehensive schema, this is sufficient for safe selection. However, it does not explicitly mention session constraints or process-group behavior, which are left to the schema, so it is not fully comprehensive on its own.

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 itself documents each parameter thoroughly (e.g., signal enum, session null restriction, process_id provenance). The description adds no additional parameter meaning beyond what the schema already provides, matching the baseline score 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 clearly states the tool's purpose: 'Signal an owned process.' This is a specific verb+resource construction that distinguishes it from sibling tools like colab_process_status (inspect) and colab_process_list. It also adds a critical scope restriction ('owned') and a safety condition ('never signal a replacement'), which uniquely identifies the tool's role.

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 provides explicit when-to-use guidance: 'If already exited/lost, inspect status; never signal a replacement.' This tells the agent not to signal dead or replaced processes and to instead inspect status. It could be improved by naming the specific status tool (colab_process_status) or listing alternatives, but the conditional instruction is clear and actionable.

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

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

No annotations are provided, so the description carries the full transparency burden. It discloses only the retry condition, which is cryptic ('request_not_submitted') and omits side effects, return value, or error behavior. This is insufficient for an operation that starts a potentially long-running process.

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 extremely compact—two short sentences—with no filler words. It front-loads the key concept of durable lease-based start, though the terse phrasing introduces ambiguity that reduces clarity.

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 process-start tool with no output schema and no annotations, the description is far from complete. It omits return value, lifecycle context, concrete retry semantics, and prerequisites beyond 'under a lease,' leaving substantial gaps for an agent.

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 input schema provides descriptions for all 7 parameters, achieving 100% coverage. The description adds only a contextual tie to the lease_token parameter, but parameter semantics are largely handled by the schema, matching the 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?

The description uses a specific verb 'Start' and specifies a durable, lease-based process start, which distinguishes it from less durable alternatives like colab_run_command. However, it does not explicitly name sibling tools, leaving some differentiation implicit.

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

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

The description implies a lease prerequisite and gives a conditional retry rule ('retry only if request_not_submitted'), but it does not clearly state when to use this tool versus alternatives or specify exclusions. The context is minimally helpful but not 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?

With no annotations, the description carries the full burden. It discloses the fallback behavior ('use preserved metadata and restore artifacts') but does not state whether the operation has side effects or what the response contains. Some behavioral context is present, but gaps remain.

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

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

Two sentences, no wasted words. The main purpose is front-loaded, and the conditional behavior is presented efficiently. 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?

There is no output schema, and the description does not describe what a status inspection returns or what 'restore artifacts' means. The purpose is clear, but operational details needed for an agent to invoke and interpret the tool are 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?

The input schema covers both parameters with descriptions (100% coverage), and the tool description adds no parameter-specific information. Baseline of 3 applies because the schema already handles parameter semantics.

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

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

The description clearly states 'Inspect owned process' with a specific verb and resource, and the conditional about runtime vanishing adds behavioral scope that distinguishes it from sibling process tools like colab_process_list or colab_process_output.

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 conditional ('if runtime vanished') that hints at a use case, but does not explicitly mention when to use this tool over alternatives like colab_process_list or colab_process_output. No exclusionary guidance is given.

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

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

With no annotations provided, the description must fully disclose behavior. It hints at destructive actions ('release orphans only if intentional') but does not explain what 'release' or 'forget' actually do to the underlying data, whether operations are reversible, or what side effects occur. The lack of detail is concerning for a tool that can delete or release resources.

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 extremely concise, using only two sentences to convey the core actions and a cautionary note. It is front-loaded and avoids unnecessary words. However, its brevity borders on under-specification, though for a simple two-parameter tool it remains appropriately sized.

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

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

The description lacks important context: what constitutes a 'stale record' or an 'orphan', how confirmation occurs, the consequences of releasing orphans beyond the action itself, and whether any output or report is provided. With no output schema and no annotations, the description does not fully equip an agent to use the tool safely and 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 description coverage is 100%, with both parameters (forget_stale and release_orphans) having clear descriptions. The tool description adds little beyond the schema, merely restating the concepts of forgetting and releasing. Since the schema already provides adequate semantics, a baseline score of 3 is appropriate.

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

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

The description clearly indicates the tool audits ownership and performs two specific actions: forgetting stale records and releasing orphans. While 'Audit ownership' is somewhat vague, the additional explanation makes the purpose clear and differentiates it from sibling tools, which focus on file operations, process management, and notebook 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 implies a use case—reconciling ownership and cleaning up stale or orphaned records—but it does not explicitly state when to use this tool versus alternatives, nor does it provide exclusions. The context is enough to infer typical usage, but not as explicit as recommended.

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 behavioral disclosure burden. It explicitly warns that 'prior RAM, processes, and leases are invalid' and states that dependencies/files are restored, providing key side-effect information. It does not cover return format or permission requirements, but the critical invalidation warning is clearly disclosed.

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

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

The description is two concise sentences, front-loaded with the action and followed by a critical warning. Every word earns its place, with no filler or redundancy.

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

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

For a 4-parameter tool with no annotations and no output schema, the description explains the core behavior and the primary risk (state invalidation) but omits guidance on when to use it and what the tool returns. It is adequate but leaves gaps in practical usage context.

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 baseline is 3. The description adds no parameter-level meaning beyond what the input schema already provides; the mention of 'restore dependencies/files' is not clearly tied to any specific parameter.

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

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

The description clearly states the tool resumes a notebook onto a fresh runtime and restores dependencies/files, which distinguishes it from siblings like colab_start or colab_execute_notebook by emphasizing the 'resume' action and fresh-runtime scope. However, it does not explicitly name alternative tools, so it falls slightly 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 verb 'resume' implies usage after a pause or interruption, but the description provides no explicit when-to-use guidance and does not mention alternatives. It lacks a clear statement of when to choose this over similar tools like colab_start or colab_execute_notebook.

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

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

With no annotations, the description carries the full behavioral burden. It discloses the key non-obvious behavior: the command continues running after timeout, requiring the agent to manage the process via process_id and output/status polling or signaling. This goes beyond a simple 'run command' and meaningfully prepares the agent for durability semantics.

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 sentences, front-loaded with 'Run durably.' Each clause earns its place by conveying the durability contract and the required follow-up actions. There is zero redundancy 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?

For a 6-parameter tool with no output schema and no annotations, the description is terse but touches the most critical context: durability, timeout behavior, and process management. The schema covers parameter details comprehensively, so the description doesn't need to repeat them. However, it lacks explicit mention of the return format or examples, leaving some gaps for a complex 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 baseline is 3. The description does not add additional parameter-level meaning beyond what the schema already provides; it focuses on post-run behavior. The 'retain process_id' hint relates to output, not parameter semantics, so no extra credit is warranted.

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 'Run durably' specifies a clear action (run) and implies the resource (a command). It distinguishes the tool's core value proposition (durable execution) from typical one-shot execution, though it doesn't explicitly differentiate it from sibling tools like colab_execute or colab_process_start. The mention of 'retain process_id, poll output/status, or signal' clarifies the command's lifecycle.

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 when to use the tool: for durable command execution where a timeout shouldn't kill the process. It gives actionable post-timeout guidance (retain process_id, poll output/status, signal), but it provides no explicit comparison to alternatives or exclusion criteria. The guidance 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?

With no annotations provided, the description carries the full burden of behavioral disclosure. It reveals that sessions may be stale and that runtime files should not be trusted—useful caveats that go beyond a simple list operation. It does not cover other traits like auth or rate limits, but for a read-only listing tool, this is sufficient.

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 sentences with no wasted words. It front-loads the core action ('List tracked/live sessions') and includes a concise, actionable warning in the second sentence.

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 tool with an output schema, the description covers all necessary operational knowledge: what it does, how to handle stale results, and a warning about file trust. No important gaps remain.

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 the description need not explain any. The baseline for 0 params is 4, and the description does not attempt to invent parameter details, which 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 clearly states the action (List) and resource (tracked/live sessions), making the tool's purpose unambiguous. The phrase 'tracked/live sessions' adds specificity that distinguishes it from other colab tools like process lists or file operations.

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 provides clear operational guidance: if sessions are stale, reconcile them and do not trust runtime files. It implies when to use the tool (as a session listing step) and what to do next, though it does not explicitly name an alternative tool for reconciliation.

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. It discloses a significant behavior: 'On quota/preemption, release unused sessions and retry later', which implies a destructive side effect. However, it does not state whether the call blocks, what happens to the current session, or any permission requirements.

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

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

Two short sentences, no filler. The first sentence states the purpose, and the second provides important failure-handling context. 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?

Despite full schema coverage, the description is too sparse for a tool with no annotations and no output schema. It does not explain what 'allocate compute' returns or how the caller should use the session, nor does it clarify the full scope of 'release unused sessions'.

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 both 'gpu' and 'session' have detailed descriptions. The tool description adds no extra parameter meaning, so the baseline of 3 applies.

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

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

The core action is clearly stated as 'Allocate compute', which is a specific verb+resource. The name 'colab_start' and the behavioral detail about quota/preemption help distinguish it from start-like siblings, though it could more explicitly say 'start a session'.

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 alternatives like colab_process_start or colab_allocation_probe. The only usage-related hint is the quota/preemption contingency, which is operational rather than a selection criterion.

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 fully shoulders the burden. It discloses idempotency ('idempotently') and the destructive consequence ('permanently loses RAM and /content'), which is critical for a stop 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, front-loaded with the core action, followed by a necessary warning. No fluff.

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 single-parameter tool with full schema coverage, the description covers the essential action, idempotency, and the key destructive side effect. No output schema exists, so return value documentation is not required. It is complete for the tool's complexity.

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

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

The input schema already provides a complete description for the 'session' parameter (100% coverage), and the tool description adds no additional parameter detail. Baseline of 3 applies.

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

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

The description uses a specific verb-resource pair ('Release compute') and clearly distinguishes this from sibling tools like colab_pause_notebook and colab_start by emphasizing permanent shutdown and idempotency. Could be slightly more explicit that it stops a session, but 'release compute' is clear in context.

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 'Export first; stopping permanently loses RAM and /content' gives an explicit prerequisite and warning, conveying that this should only be used when the user is ready to permanently discard session state. It doesn't name alternatives like pause, but the context is clear.

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

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

No annotations are provided, so the description carries the transparency burden. It discloses the destructive action ('Remove') and adds a safety-relevant behavioral nuance about probing and limiting cleanup to the same runtime when the lease expires. It does not detail return format, permissions, or failure handling, but the core behavior is transparent.

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, front-loaded sentences. The first states the primary action; the second adds a precise conditional. No filler or redundant content.

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 moderate complexity, no annotations, no output schema, and a safety-related conditional, the description covers the critical operational aspects. However, it omits return/error behavior and does not explicitly state what happens when the lease is valid (implicitly just cleanup). Still, the provided information is enough for an agent to invoke the tool correctly in the transfer cleanup flow.

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 fully documents all three parameters. The description adds minimal parameter-level meaning beyond restating 'returned staging paths' and referencing the lease-expired condition for lease_token. It does not compensate beyond schema guidance.

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 starts with 'Remove returned staging paths', which names the specific verb (remove), resource (staging paths), and scope (returned by failed transfers). This clearly distinguishes it from generic file removal tools like colab_fs_remove and aligns with the transfer cleanup workflow.

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 use after failed transfers to clean up returned staging paths, and provides a specific conditional guideline: 'If the lease expired, probe and clean only the same runtime.' It does not explicitly name alternatives or state when not to use, but the context is clear from the sibling toolset and phrasing.

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. It discloses atomicity, retry-once behavior with lease/fingerprint reuse, and the need for sync=true retry plus hash verification. This adds meaningful behavioral context beyond a simple 'download' label.

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 concise sentences with no filler. Every phrase earns its place, and the key behavioral attributes (atomicity, retry semantics, sync requirement) 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?

For a 12-parameter tool with no output schema and no annotations, the description is sparse. It covers failure-mode behavior but lacks general usage context, output/return expectations, and differentiation from sibling download tools. Adequate for a schema-heavy interface, but a clear gap remains.

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 adds value by explaining how sync=true relates to retries and how lease_token participates in pre-submission retries, enriching parameter semantics beyond the schema's static descriptions.

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 verb 'Download' is clear, but the description lacks a resource/scope (e.g., remote path, directory) and doesn't distinguish this from sibling colab_download. It mentions atomicity, which indicates behavior rather than purpose. It's not a tautology, but it's under-specified.

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 actionable retry guidance for pre-submission connection failures and other interruptions, which implies usage in failure scenarios. However, it does not state when to choose this tool over alternatives like colab_download or colab_fs_read, nor does it describe 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?

With no annotations provided, the description carries the full burden. It does disclose key behavioral traits: atomicity, progress reporting, and failure handling (retain transfer_id/staging_path, resume on same fingerprint, cleanup otherwise). However, it omits other important behaviors such as return value format, permissions, and whether the operation is synchronous, leaving gaps for an agent.

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 concise sentences that convey atomicity, progress, failure, resume semantics, and cleanup. No filler words; every phrase 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?

This is a complex 13-parameter transfer tool with no output schema. The description provides only high-level behavior and does not explain return values, when to use versus alternatives, or how parameters like session, lease_token, or compression interact. It is too sparse to fully inform an agent about correct invocation.

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

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

Schema description coverage is 100%, so all 13 parameters already have detailed descriptions. The tool description adds value by referencing transfer_id and 'staging_path' in context of resume/cleanup, slightly enriching the meaning of these fields, but it does not meaningfully compensate 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?

The description states a specific action ('Upload atomically with progress'), covering verb and resource. It clearly describes what the tool does, but it does not explicitly differentiate from the sibling tool 'colab_upload', which likely has a similar upload purpose.

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 given on when to use this tool versus alternatives like colab_upload. The description lacks any context about prerequisites, recommended scenarios, or exclusions, leaving the agent to guess when this tool is the right choice.

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 adds the behavioral qualifiers 'bounded' and 'checksummed,' indicating size limits and integrity verification beyond what the schema reveals. However, without annotations, it omits other important traits such as permissions, side effects, or reversibility, so transparency is partial.

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 concise sentence that front-loads the key concept ('compatibility alias') and includes useful qualifiers. It wastes no words, though it may be too terse to stand alone for full comprehension.

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

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

For an upload tool with no output schema and no annotations, the description lacks essential context: it does not explain the transfer behavior, overwrite rules, session handling, or return values. The alias reference is helpful but leaves too much to inference, making it incomplete for a standalone tool description.

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 input schema fully describes all parameters with 100% coverage, so the baseline is 3. The description does not add any parameter-specific meaning beyond the schema, such as relationships between session, local_path, and remote_path.

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 identifies the tool as a 'compatibility alias' for colab_transfer_upload, which implies it performs the same upload function but does not explicitly state the core action (e.g., 'uploads files'). The name 'colab_upload' and reference to the canonical tool provide indirect clarity, but the description is not self-contained.

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 on when to use this alias versus colab_transfer_upload or other upload-related siblings. It does not specify scenarios, exclusions, or prerequisites, leaving the agent to infer usage from the alias relationship.

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